create-loadout 1.0.1 → 1.0.2

package/README.md

@@ -80,7 +80,7 @@ your-app/
 | 🔥  | **Firecrawl**      | Web scraping service                       |
 | ⏰  | **Inngest**        | Background jobs                            |
 | 📁  | **UploadThing**    | File uploads                               |
-| 💳  | **Stripe**         | Checkout, webhooks, customer portal        |
+| 💳  | **Stripe**         | Payment service with checkout + billing    |
 | 📊  | **PostHog**        | Product analytics                          |
 | 🐛  | **Sentry**         | Error tracking                             |
 
@@ -90,27 +90,94 @@ your-app/
 
 ## How It Works
 
-### 1. Run the CLI
+### Interactive Mode
 
 ```bash
 npx create-loadout
 ```
 
-### 2. Answer the Prompts
+Answer the prompts — project name, integrations, AI provider — and you're done.
 
-- Project name
-- Which integrations you need
-- AI provider (if using AI SDK)
+### Non-Interactive Mode
 
-### 3. Start Building
+Skip the prompts entirely with CLI flags:
+
+```bash
+npx create-loadout my-app --clerk --neon-drizzle --stripe
+```
+
+All available flags:
+
+```
+--clerk              Clerk authentication
+--neon-drizzle       Neon + Drizzle database
+--ai-sdk             Vercel AI SDK
+--ai-provider <p>    AI provider (openai, anthropic, google)
+--resend             Resend email
+--postmark           Postmark email
+--firecrawl          Firecrawl web scraping
+--inngest            Inngest background jobs
+--uploadthing        UploadThing file uploads
+--stripe             Stripe payments
+--posthog            PostHog analytics
+--sentry             Sentry error tracking
+```
+
+Add integrations to an existing project:
+
+```bash
+npx create-loadout --add --posthog --sentry
+```
+
+Use a config file:
+
+```bash
+npx create-loadout --config loadout.json
+```
+
+```json
+{
+  "name": "my-app",
+  "integrations": ["clerk", "neon-drizzle", "stripe"],
+  "aiProvider": "anthropic"
+}
+```
+
+List all integrations as JSON:
+
+```bash
+npx create-loadout --list
+```
+
+### Start Building
 
 ```bash
 cd your-app
-npm install
 npm run dev
 ```
 
-That's it. Fill in `.env.local` and you're live.
+Fill in `.env.local` and you're live.
+
+---
+
+## MCP Server for Claude Code
+
+Loadout ships an MCP server so Claude Code agents can scaffold and extend projects programmatically.
+
+### Register
+
+```bash
+claude mcp add create-loadout -- npx -y create-loadout-mcp
+```
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `list_integrations` | List all integrations with metadata, env vars, and constraints |
+| `create_project` | Scaffold a new Next.js project with selected integrations |
+| `add_integrations` | Add integrations to an existing project |
+| `detect_project` | Check if a directory is a Next.js project, list installed/available integrations |
 
 ---
 

package/dist/cli.js

@@ -1,19 +1,16 @@
 import chalk from 'chalk';
 import ora from 'ora';
-import fs from 'fs/promises';
 import path from 'path';
 import { getProjectConfig, getAddIntegrationConfig } from './prompts.js';
-import { createNextApp } from './create-next.js';
-import { setupShadcn } from './setup-shadcn.js';
-import { installIntegrations } from './integrations/index.js';
-import { generateClaudeMd, appendClaudeMd } from './claude-md.js';
-import { generateEnvFiles, appendEnvFiles } from './env.js';
-import { generateConfig, appendConfig } from './config.js';
-import { generateReadme, generateGitignore } from './generate-readme.js';
-import { generateInstrumentationClient, generateInstrumentation, } from './instrumentation.js';
-import { zustandTemplates } from './templates/zustand.js';
-import { generateLandingPage } from './landing-page.js';
+import { createProject, addIntegrations } from './engine.js';
 import { isExistingProject, getInstalledIntegrations, getAvailableIntegrations, } from './detect.js';
+function oraReporter() {
+    const spinner = ora();
+    const callback = (step) => {
+        spinner.start(step);
+    };
+    return { spinner, callback };
+}
 export async function main() {
     console.log();
     console.log(chalk.bold.cyan('  create-loadout'));
@@ -37,36 +34,8 @@ export async function main() {
 async function newProjectFlow() {
     const config = await getProjectConfig();
     console.log();
-    const spinner = ora('Creating Next.js app...').start();
-    const projectPath = await createNextApp(config.name);
-    spinner.succeed('Next.js app created');
-    spinner.start('Setting up shadcn/ui...');
-    await setupShadcn(projectPath);
-    spinner.succeed('shadcn/ui configured');
-    await extendUtils(projectPath);
-    spinner.start('Installing base packages...');
-    const { execa } = await import('execa');
-    await execa('npm', ['install', 'zod@^3.24', 'zustand@^5', 'luxon@^3'], { cwd: projectPath });
-    await execa('npm', ['install', '-D', '@types/luxon'], { cwd: projectPath });
-    spinner.succeed('Base packages installed (zod, zustand, luxon)');
-    await fs.mkdir(path.join(projectPath, 'lib/stores'), { recursive: true });
-    await fs.writeFile(path.join(projectPath, 'lib/stores/counter.store.ts'), zustandTemplates.exampleStore);
-    if (config.integrations.length > 0) {
-        spinner.start(`Setting up ${config.integrations.length} integration(s)...`);
-        await installIntegrations(projectPath, config);
-        spinner.succeed('Integrations configured');
-    }
-    await generateInstrumentationClient(projectPath, config);
-    await generateInstrumentation(projectPath, config);
-    spinner.start('Generating config and environment files...');
-    await generateConfig(projectPath, config);
-    await generateEnvFiles(projectPath, config);
-    spinner.succeed('Config and environment files created');
-    spinner.start('Generating project files...');
-    await generateLandingPage(projectPath, config);
-    await generateGitignore(projectPath);
-    await generateReadme(projectPath, config);
-    await generateClaudeMd(projectPath, config);
+    const { spinner, callback } = oraReporter();
+    const result = await createProject(config, callback);
     spinner.succeed('Project files created');
     console.log();
     console.log(chalk.green.bold('  Success!') + ' Created ' + chalk.cyan(config.name));
@@ -117,21 +86,14 @@ async function addIntegrationFlow(projectPath) {
         return;
     }
     console.log();
-    const spinner = ora(`Installing ${addConfig.integrations.length} integration(s)...`).start();
     const config = {
         name: path.basename(projectPath),
         integrations: addConfig.integrations,
         aiProvider: addConfig.aiProvider,
     };
-    await installIntegrations(projectPath, config);
+    const { spinner, callback } = oraReporter();
+    const result = await addIntegrations(projectPath, config, callback);
     spinner.succeed('Integrations installed');
-    spinner.start('Updating config and environment files...');
-    await appendConfig(projectPath, addConfig.integrations, addConfig.aiProvider);
-    await appendEnvFiles(projectPath, addConfig.integrations, addConfig.aiProvider);
-    spinner.succeed('Config and environment files updated');
-    spinner.start('Updating CLAUDE.md...');
-    await appendClaudeMd(projectPath, addConfig.integrations);
-    spinner.succeed('CLAUDE.md updated');
     console.log();
     console.log(chalk.green.bold('  Success!') + ' Added integrations:');
     addConfig.integrations.forEach((integration) => {
@@ -155,32 +117,3 @@ async function addIntegrationFlow(projectPath) {
         console.log();
     }
 }
-async function extendUtils(projectPath) {
-    const utilsPath = path.join(projectPath, 'lib/utils.ts');
-    const existingContent = await fs.readFile(utilsPath, 'utf-8');
-    const additionalUtils = `
-import { DateTime } from 'luxon';
-
-export function formatDate(date: Date | string, format = 'LLL d, yyyy'): string {
-  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
-  return dt.toFormat(format);
-}
-
-export function formatRelative(date: Date | string): string {
-  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
-  return dt.toRelative() ?? dt.toFormat('LLL d, yyyy');
-}
-
-export function debounce<P extends unknown[], R>(
-  func: (...args: P) => R,
-  wait: number
-): (...args: P) => void {
-  let timeout: ReturnType<typeof setTimeout>;
-  return (...args: P) => {
-    clearTimeout(timeout);
-    timeout = setTimeout(() => func(...args), wait);
-  };
-}
-`;
-    await fs.writeFile(utilsPath, existingContent + additionalUtils);
-}

package/dist/create-next.js

@@ -11,7 +11,7 @@ export async function createNextApp(name) {
         '--import-alias', '@/*',
         '--yes',
     ], {
-        stdio: 'inherit',
+        stdio: 'pipe',
     });
     return path.resolve(process.cwd(), name);
 }

package/dist/engine.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectConfig, IntegrationId } from './types.js';
+export type ProgressCallback = (step: string) => void;
+export interface EngineResult {
+    projectPath: string;
+    integrations: IntegrationId[];
+    envVarsNeeded: string[];
+}
+export declare function createProject(config: ProjectConfig, onProgress?: ProgressCallback): Promise<EngineResult>;
+export declare function addIntegrations(projectPath: string, config: ProjectConfig, onProgress?: ProgressCallback): Promise<EngineResult>;

package/dist/engine.js

@@ -0,0 +1,84 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { createNextApp } from './create-next.js';
+import { setupShadcn } from './setup-shadcn.js';
+import { installIntegrations, getEnvVars } from './integrations/index.js';
+import { generateClaudeMd, appendClaudeMd } from './claude-md.js';
+import { generateEnvFiles, appendEnvFiles } from './env.js';
+import { generateConfig, appendConfig } from './config.js';
+import { generateReadme, generateGitignore } from './generate-readme.js';
+import { generateInstrumentationClient, generateInstrumentation, } from './instrumentation.js';
+import { zustandTemplates } from './templates/zustand.js';
+import { generateLandingPage } from './landing-page.js';
+export async function createProject(config, onProgress) {
+    onProgress?.('Creating Next.js app...');
+    const projectPath = await createNextApp(config.name);
+    onProgress?.('Setting up shadcn/ui...');
+    await setupShadcn(projectPath);
+    await extendUtils(projectPath);
+    onProgress?.('Installing base packages...');
+    const { execa } = await import('execa');
+    await execa('npm', ['install', 'zod@^3.24', 'zustand@^5', 'luxon@^3'], { cwd: projectPath });
+    await execa('npm', ['install', '-D', '@types/luxon'], { cwd: projectPath });
+    await fs.mkdir(path.join(projectPath, 'lib/stores'), { recursive: true });
+    await fs.writeFile(path.join(projectPath, 'lib/stores/counter.store.ts'), zustandTemplates.exampleStore);
+    if (config.integrations.length > 0) {
+        onProgress?.(`Setting up ${config.integrations.length} integration(s)...`);
+        await installIntegrations(projectPath, config);
+    }
+    await generateInstrumentationClient(projectPath, config);
+    await generateInstrumentation(projectPath, config);
+    onProgress?.('Generating config and environment files...');
+    await generateConfig(projectPath, config);
+    await generateEnvFiles(projectPath, config);
+    onProgress?.('Generating project files...');
+    await generateLandingPage(projectPath, config);
+    await generateGitignore(projectPath);
+    await generateReadme(projectPath, config);
+    await generateClaudeMd(projectPath, config);
+    const envVarsNeeded = collectEnvVars(config);
+    return { projectPath, integrations: config.integrations, envVarsNeeded };
+}
+export async function addIntegrations(projectPath, config, onProgress) {
+    onProgress?.(`Installing ${config.integrations.length} integration(s)...`);
+    await installIntegrations(projectPath, config);
+    onProgress?.('Updating config and environment files...');
+    await appendConfig(projectPath, config.integrations, config.aiProvider);
+    await appendEnvFiles(projectPath, config.integrations, config.aiProvider);
+    onProgress?.('Updating CLAUDE.md...');
+    await appendClaudeMd(projectPath, config.integrations);
+    const envVarsNeeded = collectEnvVars(config);
+    return { projectPath, integrations: config.integrations, envVarsNeeded };
+}
+async function extendUtils(projectPath) {
+    const utilsPath = path.join(projectPath, 'lib/utils.ts');
+    const existingContent = await fs.readFile(utilsPath, 'utf-8');
+    const additionalUtils = `
+import { DateTime } from 'luxon';
+
+export function formatDate(date: Date | string, format = 'LLL d, yyyy'): string {
+  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
+  return dt.toFormat(format);
+}
+
+export function formatRelative(date: Date | string): string {
+  const dt = typeof date === 'string' ? DateTime.fromISO(date) : DateTime.fromJSDate(date);
+  return dt.toRelative() ?? dt.toFormat('LLL d, yyyy');
+}
+
+export function debounce<P extends unknown[], R>(
+  func: (...args: P) => R,
+  wait: number
+): (...args: P) => void {
+  let timeout: ReturnType<typeof setTimeout>;
+  return (...args: P) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+`;
+    await fs.writeFile(utilsPath, existingContent + additionalUtils);
+}
+function collectEnvVars(config) {
+    return getEnvVars(config).map((v) => v.key);
+}

package/dist/index.js

@@ -1,3 +1,158 @@
 #!/usr/bin/env node
+import { Command } from 'commander';
 import { main } from './cli.js';
-main();
+import { createProject, addIntegrations } from './engine.js';
+import { validateProjectConfig, validateIntegrationSelection, ALL_INTEGRATION_IDS } from './validate.js';
+import { listIntegrations } from './metadata.js';
+import { isExistingProject, getInstalledIntegrations } from './detect.js';
+import fs from 'fs/promises';
+import path from 'path';
+const program = new Command();
+program
+    .name('create-loadout')
+    .description('Custom Next.js scaffolding with SaaS integrations')
+    .version('1.0.1')
+    .argument('[name]', 'Project name')
+    .option('--clerk', 'Add Clerk authentication')
+    .option('--neon-drizzle', 'Add Neon + Drizzle database')
+    .option('--ai-sdk', 'Add Vercel AI SDK')
+    .option('--ai-provider <provider>', 'AI provider (openai, anthropic, google)')
+    .option('--resend', 'Add Resend email')
+    .option('--postmark', 'Add Postmark email')
+    .option('--firecrawl', 'Add Firecrawl web scraping')
+    .option('--inngest', 'Add Inngest background jobs')
+    .option('--uploadthing', 'Add UploadThing file uploads')
+    .option('--stripe', 'Add Stripe payments')
+    .option('--posthog', 'Add PostHog analytics')
+    .option('--sentry', 'Add Sentry error tracking')
+    .option('--config <path>', 'Path to loadout.json config file')
+    .option('--add', 'Add integrations to existing project')
+    .option('--list', 'List all available integrations as JSON')
+    .action(async (name, opts) => {
+    // --list: dump integration metadata and exit
+    if (opts.list) {
+        console.log(JSON.stringify(listIntegrations(), null, 2));
+        return;
+    }
+    // Detect if running non-interactive
+    const hasConfig = typeof opts.config === 'string';
+    const hasFlags = name || hasConfig || opts.add || integrationFlagsPresent(opts);
+    if (!hasFlags) {
+        // No flags → interactive mode (existing behavior)
+        await main();
+        return;
+    }
+    // Non-interactive mode
+    try {
+        if (hasConfig) {
+            await runFromConfigFile(opts.config);
+        }
+        else if (opts.add) {
+            await runAddMode(opts);
+        }
+        else {
+            await runCreateMode(name, opts);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+function integrationFlagsPresent(opts) {
+    return ALL_INTEGRATION_IDS.some((id) => opts[camelCase(id)] === true);
+}
+function camelCase(s) {
+    return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function collectIntegrations(opts) {
+    const integrations = [];
+    for (const id of ALL_INTEGRATION_IDS) {
+        if (opts[camelCase(id)] === true) {
+            integrations.push(id);
+        }
+    }
+    return integrations;
+}
+async function runCreateMode(name, opts) {
+    const integrations = collectIntegrations(opts);
+    const aiProvider = opts.aiProvider || undefined;
+    const config = { name, integrations, aiProvider };
+    const errors = validateProjectConfig(config);
+    if (errors.length > 0) {
+        console.error('Validation errors:');
+        errors.forEach((e) => console.error(`  - ${e.field}: ${e.message}`));
+        process.exit(1);
+    }
+    const result = await createProject(config, (step) => console.log(step));
+    console.log();
+    console.log(`Success! Created ${config.name} at ${result.projectPath}`);
+    if (result.integrations.length > 0) {
+        console.log(`Integrations: ${result.integrations.join(', ')}`);
+    }
+    if (result.envVarsNeeded.length > 0) {
+        console.log(`Environment variables to configure: ${result.envVarsNeeded.join(', ')}`);
+    }
+}
+async function runAddMode(opts) {
+    const cwd = process.cwd();
+    if (!(await isExistingProject(cwd))) {
+        console.error('Error: Not in a Next.js project directory. --add requires an existing project.');
+        process.exit(1);
+    }
+    const integrations = collectIntegrations(opts);
+    if (integrations.length === 0) {
+        console.error('Error: --add requires at least one integration flag (e.g. --clerk --stripe)');
+        process.exit(1);
+    }
+    const valErrors = validateIntegrationSelection(integrations);
+    if (valErrors.length > 0) {
+        console.error('Validation errors:');
+        valErrors.forEach((e) => console.error(`  - ${e.field}: ${e.message}`));
+        process.exit(1);
+    }
+    const installed = await getInstalledIntegrations(cwd);
+    const alreadyInstalled = integrations.filter((id) => installed.includes(id));
+    if (alreadyInstalled.length > 0) {
+        console.error(`Error: Already installed: ${alreadyInstalled.join(', ')}`);
+        process.exit(1);
+    }
+    const aiProvider = opts.aiProvider || undefined;
+    const config = {
+        name: path.basename(cwd),
+        integrations,
+        aiProvider,
+    };
+    const result = await addIntegrations(cwd, config, (step) => console.log(step));
+    console.log();
+    console.log(`Success! Added integrations: ${result.integrations.join(', ')}`);
+    if (result.envVarsNeeded.length > 0) {
+        console.log(`Environment variables to configure: ${result.envVarsNeeded.join(', ')}`);
+    }
+}
+async function runFromConfigFile(configPath) {
+    const resolved = path.resolve(configPath);
+    const raw = await fs.readFile(resolved, 'utf-8');
+    const parsed = JSON.parse(raw);
+    const config = {
+        name: parsed.name,
+        integrations: parsed.integrations || [],
+        aiProvider: parsed.aiProvider,
+    };
+    const errors = validateProjectConfig(config);
+    if (errors.length > 0) {
+        console.error('Config validation errors:');
+        errors.forEach((e) => console.error(`  - ${e.field}: ${e.message}`));
+        process.exit(1);
+    }
+    const result = await createProject(config, (step) => console.log(step));
+    console.log();
+    console.log(`Success! Created ${config.name} at ${result.projectPath}`);
+    if (result.integrations.length > 0) {
+        console.log(`Integrations: ${result.integrations.join(', ')}`);
+    }
+    if (result.envVarsNeeded.length > 0) {
+        console.log(`Environment variables to configure: ${result.envVarsNeeded.join(', ')}`);
+    }
+}
+program.parse();

package/dist/integrations/index.d.ts

@@ -1,4 +1,5 @@
 import type { Integration, IntegrationId, EnvVar, ProjectConfig } from '../types.js';
+export declare function getIntegration(id: IntegrationId, config: ProjectConfig): Integration;
 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

@@ -24,7 +24,7 @@ const staticIntegrations = {
     sentry: sentryIntegration,
 };
 // Get integration, with dynamic ones using config
-function getIntegration(id, config) {
+export function getIntegration(id, config) {
     if (id === 'ai-sdk') {
         return createAiSdkIntegration(config.aiProvider ?? 'openai');
     }

package/dist/integrations/stripe.js

@@ -25,21 +25,7 @@ export const stripeIntegration = {
         },
     ],
     setup: async (projectPath) => {
-        // Create payment service
         await fs.mkdir(path.join(projectPath, 'services'), { recursive: true });
         await fs.writeFile(path.join(projectPath, 'services/payment.service.ts'), stripeTemplates.paymentService);
-        // Create API routes
-        await fs.mkdir(path.join(projectPath, 'app/api/stripe/checkout'), {
-            recursive: true,
-        });
-        await fs.mkdir(path.join(projectPath, 'app/api/stripe/webhooks'), {
-            recursive: true,
-        });
-        await fs.mkdir(path.join(projectPath, 'app/api/stripe/portal'), {
-            recursive: true,
-        });
-        await fs.writeFile(path.join(projectPath, 'app/api/stripe/checkout/route.ts'), stripeTemplates.checkoutRoute);
-        await fs.writeFile(path.join(projectPath, 'app/api/stripe/webhooks/route.ts'), stripeTemplates.webhooksRoute);
-        await fs.writeFile(path.join(projectPath, 'app/api/stripe/portal/route.ts'), stripeTemplates.portalRoute);
     },
 };

package/dist/mcp-server.d.ts

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

package/dist/mcp-server.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import path from 'path';
+import { createProject, addIntegrations } from './engine.js';
+import { validateProjectConfig, validateIntegrationSelection, } from './validate.js';
+import { listIntegrations } from './metadata.js';
+import { isExistingProject, getInstalledIntegrations, getAvailableIntegrations, } from './detect.js';
+const server = new McpServer({
+    name: 'create-loadout',
+    version: '1.0.1',
+});
+// Tool: list_integrations
+server.tool('list_integrations', 'List all available integrations with metadata, env vars, and constraints', {}, async () => {
+    const integrations = listIntegrations();
+    return {
+        content: [{ type: 'text', text: JSON.stringify(integrations, null, 2) }],
+    };
+});
+// Tool: create_project
+server.tool('create_project', 'Scaffold a new Next.js project with selected integrations', {
+    name: z.string().describe('Project name (lowercase, numbers, hyphens only)'),
+    integrations: z.array(z.string()).default([]).describe('Integration IDs to install'),
+    aiProvider: z.enum(['openai', 'anthropic', 'google']).optional().describe('AI provider (required if ai-sdk selected)'),
+}, async ({ name, integrations, aiProvider }) => {
+    const config = {
+        name,
+        integrations: integrations,
+        aiProvider: aiProvider,
+    };
+    const errors = validateProjectConfig(config);
+    if (errors.length > 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ error: 'Validation failed', details: errors }),
+                }],
+            isError: true,
+        };
+    }
+    const log = [];
+    const result = await createProject(config, (step) => log.push(step));
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: true,
+                    projectPath: result.projectPath,
+                    integrations: result.integrations,
+                    envVarsNeeded: result.envVarsNeeded,
+                    log,
+                }, null, 2),
+            }],
+    };
+});
+// Tool: add_integrations
+server.tool('add_integrations', 'Add integrations to an existing Next.js project', {
+    projectPath: z.string().describe('Absolute path to the existing Next.js project'),
+    integrations: z.array(z.string()).describe('Integration IDs to add'),
+    aiProvider: z.enum(['openai', 'anthropic', 'google']).optional().describe('AI provider (required if ai-sdk selected)'),
+}, async ({ projectPath, integrations, aiProvider }) => {
+    const resolved = path.resolve(projectPath);
+    if (!(await isExistingProject(resolved))) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ error: 'Not a Next.js project', path: resolved }),
+                }],
+            isError: true,
+        };
+    }
+    const valErrors = validateIntegrationSelection(integrations);
+    if (valErrors.length > 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ error: 'Validation failed', details: valErrors }),
+                }],
+            isError: true,
+        };
+    }
+    const installed = await getInstalledIntegrations(resolved);
+    const alreadyInstalled = integrations.filter((id) => installed.includes(id));
+    if (alreadyInstalled.length > 0) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ error: 'Already installed', integrations: alreadyInstalled }),
+                }],
+            isError: true,
+        };
+    }
+    if (integrations.includes('ai-sdk') && !aiProvider) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ error: 'aiProvider required when ai-sdk is selected' }),
+                }],
+            isError: true,
+        };
+    }
+    const config = {
+        name: path.basename(resolved),
+        integrations: integrations,
+        aiProvider: aiProvider,
+    };
+    const log = [];
+    const result = await addIntegrations(resolved, config, (step) => log.push(step));
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    success: true,
+                    projectPath: result.projectPath,
+                    integrations: result.integrations,
+                    envVarsNeeded: result.envVarsNeeded,
+                    log,
+                }, null, 2),
+            }],
+    };
+});
+// Tool: detect_project
+server.tool('detect_project', 'Check if a directory is a Next.js project and list installed/available integrations', {
+    projectPath: z.string().optional().describe('Path to check (defaults to cwd)'),
+}, async ({ projectPath }) => {
+    const resolved = path.resolve(projectPath || process.cwd());
+    const isProject = await isExistingProject(resolved);
+    if (!isProject) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        isNextJsProject: false,
+                        path: resolved,
+                    }, null, 2),
+                }],
+        };
+    }
+    const installed = await getInstalledIntegrations(resolved);
+    const available = getAvailableIntegrations(installed);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    isNextJsProject: true,
+                    path: resolved,
+                    installedIntegrations: installed,
+                    availableIntegrations: available,
+                }, null, 2),
+            }],
+    };
+});
+async function run() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+run().catch((error) => {
+    console.error('MCP server error:', error);
+    process.exit(1);
+});

package/dist/metadata.d.ts

@@ -0,0 +1,18 @@
+import type { IntegrationId } from './types.js';
+export interface IntegrationInfo {
+    id: IntegrationId;
+    name: string;
+    description: string;
+    packages: string[];
+    envVars: {
+        key: string;
+        description: string;
+        example: string;
+    }[];
+    mutuallyExclusiveWith?: IntegrationId[];
+    requiresOption?: {
+        field: string;
+        values: string[];
+    };
+}
+export declare function listIntegrations(): IntegrationInfo[];

package/dist/metadata.js

@@ -0,0 +1,28 @@
+import { getIntegration } from './integrations/index.js';
+import { ALL_INTEGRATION_IDS, AI_PROVIDERS } from './validate.js';
+const EMAIL_PROVIDERS = ['resend', 'postmark'];
+export function listIntegrations() {
+    return ALL_INTEGRATION_IDS.map((id) => {
+        // Use a dummy config to get integration metadata
+        const config = { name: 'dummy', integrations: [id], aiProvider: 'openai' };
+        const integration = getIntegration(id, config);
+        const info = {
+            id: integration.id,
+            name: integration.name,
+            description: integration.description,
+            packages: integration.packages,
+            envVars: integration.envVars.map((v) => ({
+                key: v.key,
+                description: v.description,
+                example: v.example,
+            })),
+        };
+        if (EMAIL_PROVIDERS.includes(id)) {
+            info.mutuallyExclusiveWith = EMAIL_PROVIDERS.filter((e) => e !== id);
+        }
+        if (id === 'ai-sdk') {
+            info.requiresOption = { field: 'aiProvider', values: [...AI_PROVIDERS] };
+        }
+        return info;
+    });
+}

package/dist/prompts.js

@@ -1,15 +1,12 @@
 import { input, confirm, select } from '@inquirer/prompts';
+import { validateProjectName } from './validate.js';
 export async function getProjectConfig() {
     const name = await input({
         message: 'Project name:',
         default: 'my-app',
         validate: (value) => {
-            if (!value.trim())
-                return 'Project name is required';
-            if (!/^[a-z0-9-]+$/.test(value)) {
-                return 'Project name can only contain lowercase letters, numbers, and hyphens';
-            }
-            return true;
+            const errors = validateProjectName(value);
+            return errors.length > 0 ? errors[0].message : true;
         },
     });
     const integrations = [];

package/dist/templates/firecrawl.js

@@ -78,7 +78,7 @@ import { scrapeService } from '@/services/scrape.service';
 import { z } from 'zod';
 
 const scrapeSchema = z.object({
-  url: z.url(),
+  url: z.string().url(),
 });
 
 export async function POST(req: Request) {

package/dist/templates/stripe.d.ts

@@ -1,6 +1,3 @@
 export declare const stripeTemplates: {
     paymentService: string;
-    checkoutRoute: string;
-    webhooksRoute: string;
-    portalRoute: string;
 };

package/dist/templates/stripe.js

@@ -81,135 +81,5 @@ export class PaymentService {
 export const paymentService = new PaymentService(STRIPE_SECRET_KEY);
 
 export type { Stripe };
-`,
-    checkoutRoute: `import { NextResponse } from 'next/server';
-import { paymentService } from '@/services/payment.service';
-import { z } from 'zod';
-
-const checkoutSchema = z.object({
-  priceId: z.string(),
-  customerId: z.string().optional(),
-  successUrl: z.url(),
-  cancelUrl: z.url(),
-});
-
-export async function POST(req: Request) {
-  try {
-    const body = await req.json();
-    const { priceId, customerId, successUrl, cancelUrl } = checkoutSchema.parse(body);
-
-    const session = await paymentService.createCheckoutSession({
-      priceId,
-      customerId,
-      successUrl,
-      cancelUrl,
-    });
-
-    return NextResponse.json({ url: session.url });
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return NextResponse.json(
-        { error: 'Invalid request', details: error.errors },
-        { status: 400 }
-      );
-    }
-    return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Failed to create checkout' },
-      { status: 500 }
-    );
-  }
-}
-`,
-    webhooksRoute: `import { headers } from 'next/headers';
-import { NextResponse } from 'next/server';
-import { paymentService, type Stripe } from '@/services/payment.service';
-import { STRIPE_WEBHOOK_SECRET } from '@/lib/config';
-
-export async function POST(req: Request) {
-  const body = await req.text();
-  const headersList = await headers();
-  const signature = headersList.get('stripe-signature')!;
-
-  let event: Stripe.Event;
-
-  try {
-    event = paymentService.constructWebhookEvent(body, signature, STRIPE_WEBHOOK_SECRET);
-  } catch (error) {
-    console.error('Webhook signature verification failed:', error);
-    return NextResponse.json({ error: 'Invalid signature' }, { status: 400 });
-  }
-
-  switch (event.type) {
-    case 'checkout.session.completed': {
-      const session = event.data.object as Stripe.Checkout.Session;
-      console.log('Checkout completed:', session.id);
-      break;
-    }
-
-    case 'customer.subscription.created':
-    case 'customer.subscription.updated': {
-      const subscription = event.data.object as Stripe.Subscription;
-      console.log('Subscription updated:', subscription.id, subscription.status);
-      break;
-    }
-
-    case 'customer.subscription.deleted': {
-      const subscription = event.data.object as Stripe.Subscription;
-      console.log('Subscription cancelled:', subscription.id);
-      break;
-    }
-
-    case 'invoice.payment_succeeded': {
-      const invoice = event.data.object as Stripe.Invoice;
-      console.log('Payment succeeded:', invoice.id);
-      break;
-    }
-
-    case 'invoice.payment_failed': {
-      const invoice = event.data.object as Stripe.Invoice;
-      console.log('Payment failed:', invoice.id);
-      break;
-    }
-
-    default:
-      console.log('Unhandled event type:', event.type);
-  }
-
-  return NextResponse.json({ received: true });
-}
-`,
-    portalRoute: `import { NextResponse } from 'next/server';
-import { paymentService } from '@/services/payment.service';
-import { z } from 'zod';
-
-const portalSchema = z.object({
-  customerId: z.string(),
-  returnUrl: z.url(),
-});
-
-export async function POST(req: Request) {
-  try {
-    const body = await req.json();
-    const { customerId, returnUrl } = portalSchema.parse(body);
-
-    const session = await paymentService.createPortalSession({
-      customerId,
-      returnUrl,
-    });
-
-    return NextResponse.json({ url: session.url });
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      return NextResponse.json(
-        { error: 'Invalid request', details: error.errors },
-        { status: 400 }
-      );
-    }
-    return NextResponse.json(
-      { error: error instanceof Error ? error.message : 'Failed to create portal session' },
-      { status: 500 }
-    );
-  }
-}
 `,
 };

package/dist/validate.d.ts

@@ -0,0 +1,14 @@
+import type { IntegrationId, AIProviderChoice } from './types.js';
+export declare const ALL_INTEGRATION_IDS: IntegrationId[];
+export declare const AI_PROVIDERS: AIProviderChoice[];
+export interface ValidationError {
+    field: string;
+    message: string;
+}
+export declare function validateProjectName(name: string): ValidationError[];
+export declare function validateIntegrationSelection(ids: string[]): ValidationError[];
+export declare function validateProjectConfig(config: {
+    name: string;
+    integrations: string[];
+    aiProvider?: string;
+}): ValidationError[];

package/dist/validate.js

@@ -0,0 +1,66 @@
+export const ALL_INTEGRATION_IDS = [
+    'clerk',
+    'neon-drizzle',
+    'ai-sdk',
+    'resend',
+    'postmark',
+    'firecrawl',
+    'inngest',
+    'uploadthing',
+    'stripe',
+    'posthog',
+    'sentry',
+];
+export const AI_PROVIDERS = ['openai', 'anthropic', 'google'];
+const EMAIL_PROVIDERS = ['resend', 'postmark'];
+const PROJECT_NAME_REGEX = /^[a-z0-9-]+$/;
+export function validateProjectName(name) {
+    const errors = [];
+    if (!name.trim()) {
+        errors.push({ field: 'name', message: 'Project name is required' });
+    }
+    else if (!PROJECT_NAME_REGEX.test(name)) {
+        errors.push({
+            field: 'name',
+            message: 'Project name can only contain lowercase letters, numbers, and hyphens',
+        });
+    }
+    return errors;
+}
+export function validateIntegrationSelection(ids) {
+    const errors = [];
+    for (const id of ids) {
+        if (!ALL_INTEGRATION_IDS.includes(id)) {
+            errors.push({
+                field: 'integrations',
+                message: `Unknown integration: "${id}". Valid: ${ALL_INTEGRATION_IDS.join(', ')}`,
+            });
+        }
+    }
+    const selectedEmail = ids.filter((id) => EMAIL_PROVIDERS.includes(id));
+    if (selectedEmail.length > 1) {
+        errors.push({
+            field: 'integrations',
+            message: 'Only one email provider allowed (resend or postmark)',
+        });
+    }
+    return errors;
+}
+export function validateProjectConfig(config) {
+    const errors = [];
+    errors.push(...validateProjectName(config.name));
+    errors.push(...validateIntegrationSelection(config.integrations));
+    if (config.integrations.includes('ai-sdk') && !config.aiProvider) {
+        errors.push({
+            field: 'aiProvider',
+            message: 'aiProvider is required when ai-sdk is selected (openai, anthropic, or google)',
+        });
+    }
+    if (config.aiProvider && !AI_PROVIDERS.includes(config.aiProvider)) {
+        errors.push({
+            field: 'aiProvider',
+            message: `Invalid AI provider: "${config.aiProvider}". Valid: ${AI_PROVIDERS.join(', ')}`,
+        });
+    }
+    return errors;
+}

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "create-loadout",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Custom Next.js scaffolding CLI with optional SaaS integrations",
   "type": "module",
   "bin": {
-    "create-loadout": "./dist/index.js"
+    "create-loadout": "./dist/index.js",
+    "create-loadout-mcp": "./dist/mcp-server.js"
   },
   "files": [
     "dist"
@@ -12,6 +13,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/index.ts",
+    "create": "tsx src/index.ts",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -31,14 +33,17 @@
   "license": "MIT",
   "dependencies": {
     "@inquirer/prompts": "^7.0.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "chalk": "^5.0.0",
+    "commander": "^13.1.0",
+    "execa": "^9.0.0",
     "ora": "^8.0.0",
-    "execa": "^9.0.0"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
-    "typescript": "^5.0.0",
-    "tsx": "^4.0.0"
+    "tsx": "^4.0.0",
+    "typescript": "^5.0.0"
   },
   "engines": {
     "node": ">=18.0.0"