create-loadout 1.0.1 → 1.0.4

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,165 @@
+#!/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';
+const nodeBinDir = path.dirname(process.execPath);
+if (!process.env.PATH?.includes(nodeBinDir)) {
+    process.env.PATH = `${nodeBinDir}:${process.env.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) {