create-aws-project 1.2.1

package/dist/aws/organizations.js

@@ -0,0 +1,168 @@
+import { OrganizationsClient, CreateOrganizationCommand, CreateAccountCommand, DescribeCreateAccountStatusCommand, DescribeOrganizationCommand, AlreadyInOrganizationException, } from '@aws-sdk/client-organizations';
+import pc from 'picocolors';
+/**
+ * AWS Organizations service module
+ *
+ * Provides functions to create AWS Organizations and member accounts
+ * programmatically during project generation.
+ */
+/**
+ * Creates a configured OrganizationsClient
+ * @param region - AWS region (defaults to us-east-1 as Organizations API is global)
+ * @returns Configured OrganizationsClient instance
+ */
+export function createOrganizationsClient(region = 'us-east-1') {
+    return new OrganizationsClient({ region });
+}
+/**
+ * Checks if the current AWS account is already part of an organization
+ * @param client - OrganizationsClient instance
+ * @returns Organization ID if exists, null if not in an organization
+ */
+export async function checkExistingOrganization(client) {
+    try {
+        const command = new DescribeOrganizationCommand({});
+        const response = await client.send(command);
+        return response.Organization?.Id ?? null;
+    }
+    catch (error) {
+        // AWSOrganizationsNotInUseException means no organization exists
+        if (error instanceof Error && error.name === 'AWSOrganizationsNotInUseException') {
+            return null;
+        }
+        throw error;
+    }
+}
+/**
+ * Creates a new AWS Organization with all features enabled
+ * @param client - OrganizationsClient instance
+ * @returns Organization ID of the newly created organization
+ * @throws Error if organization creation fails (except for already existing)
+ */
+export async function createOrganization(client) {
+    try {
+        const command = new CreateOrganizationCommand({
+            FeatureSet: 'ALL',
+        });
+        const response = await client.send(command);
+        if (!response.Organization?.Id) {
+            throw new Error('Organization created but no ID returned');
+        }
+        return response.Organization.Id;
+    }
+    catch (error) {
+        // If already in an organization, return the existing org ID
+        if (error instanceof AlreadyInOrganizationException) {
+            const existingOrgId = await checkExistingOrganization(client);
+            if (existingOrgId) {
+                return existingOrgId;
+            }
+            throw new Error('Already in organization but could not retrieve organization ID');
+        }
+        throw error;
+    }
+}
+/**
+ * Creates a new AWS account within the organization
+ * @param client - OrganizationsClient instance
+ * @param email - Email address for the new account's root user
+ * @param accountName - Display name for the account
+ * @returns CreateAccountStatus ID for polling
+ */
+export async function createAccount(client, email, accountName) {
+    const command = new CreateAccountCommand({
+        Email: email,
+        AccountName: accountName,
+    });
+    const response = await client.send(command);
+    if (!response.CreateAccountStatus?.Id) {
+        throw new Error('Account creation initiated but no request ID returned');
+    }
+    return {
+        requestId: response.CreateAccountStatus.Id,
+    };
+}
+/**
+ * Polls the account creation status until completion or timeout
+ * @param client - OrganizationsClient instance
+ * @param createAccountRequestId - The request ID from createAccount
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 5 minutes)
+ * @returns Account ID when creation succeeds
+ * @throws Error if creation fails or times out
+ */
+export async function waitForAccountCreation(client, createAccountRequestId, timeoutMs = 300000) {
+    const pollIntervalMs = 5000; // 5 seconds
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        const command = new DescribeCreateAccountStatusCommand({
+            CreateAccountRequestId: createAccountRequestId,
+        });
+        const response = await client.send(command);
+        const status = response.CreateAccountStatus;
+        if (!status) {
+            throw new Error('No status returned for account creation request');
+        }
+        // Use State field (not deprecated Status field)
+        const state = status.State;
+        if (state === 'SUCCEEDED') {
+            if (!status.AccountId) {
+                throw new Error('Account creation succeeded but no account ID returned');
+            }
+            return {
+                accountId: status.AccountId,
+                accountName: status.AccountName ?? '',
+            };
+        }
+        if (state === 'FAILED') {
+            const reason = status.FailureReason ?? 'Unknown failure reason';
+            throw new Error(`Account creation failed: ${reason}`);
+        }
+        // State is IN_PROGRESS, continue polling
+        await sleep(pollIntervalMs);
+    }
+    throw new Error(`Account creation timed out after ${timeoutMs / 1000} seconds`);
+}
+/**
+ * Creates multiple environment accounts sequentially
+ * @param client - OrganizationsClient instance
+ * @param orgName - Organization name prefix for account names
+ * @param accounts - Array of environment and email configurations
+ * @returns Array of created account results
+ */
+export async function createEnvironmentAccounts(client, orgName, accounts) {
+    const results = [];
+    console.log(pc.cyan('\nCreating AWS environment accounts...'));
+    console.log(pc.dim('Note: AWS rate limits require sequential account creation\n'));
+    for (const account of accounts) {
+        const accountName = `${orgName}-${account.environment}`;
+        console.log(pc.yellow(`Creating account: ${accountName}`));
+        console.log(pc.dim(`  Email: ${account.email}`));
+        try {
+            // Initiate account creation
+            const { requestId } = await createAccount(client, account.email, accountName);
+            console.log(pc.dim(`  Request ID: ${requestId}`));
+            console.log(pc.dim('  Waiting for account creation (this may take a few minutes)...'));
+            // Wait for completion
+            const result = await waitForAccountCreation(client, requestId);
+            console.log(pc.green(`  Account created: ${result.accountId}`));
+            results.push({
+                environment: account.environment,
+                email: account.email,
+                accountId: result.accountId,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.log(pc.red(`  Failed to create account: ${message}`));
+            throw new Error(`Failed to create ${account.environment} account: ${message}`);
+        }
+    }
+    console.log(pc.green(`\nSuccessfully created ${results.length} environment accounts`));
+    return results;
+}
+/**
+ * Helper function to sleep for a specified duration
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/cli.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parse command line arguments and run the CLI
+ */
+export declare function run(): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,206 @@
+import { readFileSync, existsSync, mkdirSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import pc from 'picocolors';
+import { runWizard } from './wizard.js';
+import { generateProject } from './generator/index.js';
+import { createOrganizationsClient, checkExistingOrganization, createOrganization, createEnvironmentAccounts, } from './aws/organizations.js';
+import { runSetupGitHub } from './commands/setup-github.js';
+/**
+ * Get the version from package.json
+ */
+function getVersion() {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = dirname(__filename);
+    const packageJsonPath = join(__dirname, '..', 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    return packageJson.version;
+}
+/**
+ * Print help message
+ */
+function printHelp() {
+    console.log(`
+create-aws-starter-kit [command] [options]
+
+Scaffold a new AWS Starter Kit project with React, Lambda, and CDK infrastructure.
+
+Commands:
+  (default)       Create a new project (interactive wizard)
+  setup-github    Configure GitHub Actions deployment credentials
+
+Options:
+  --help, -h      Show this help message
+  --version, -v   Show version number
+
+Usage:
+  create-aws-starter-kit [project-name]    Create a new project
+  create-aws-starter-kit setup-github      Configure GitHub deployment
+
+Examples:
+  create-aws-starter-kit my-app
+  create-aws-starter-kit setup-github
+  create-aws-starter-kit --help
+`.trim());
+}
+/**
+ * Print welcome banner
+ */
+function printWelcome() {
+    console.log(`
+╔═══════════════════════════════════════════════════════╗
+║                                                       ║
+║            create-aws-starter-kit                     ║
+║       AWS Starter Kit Project Generator               ║
+║                                                       ║
+╚═══════════════════════════════════════════════════════╝
+`.trim());
+}
+/**
+ * Print post-generation instructions
+ */
+function printNextSteps(projectName, platforms) {
+    console.log('');
+    console.log(pc.bold('Next steps:'));
+    console.log('');
+    console.log(`  ${pc.cyan('cd')} ${projectName}`);
+    console.log(`  ${pc.cyan('npm install')}`);
+    console.log('');
+    if (platforms.includes('web')) {
+        console.log(`  ${pc.gray('# Start web app')}`);
+        console.log(`  ${pc.cyan('npm run web')}`);
+        console.log('');
+    }
+    if (platforms.includes('mobile')) {
+        console.log(`  ${pc.gray('# Start mobile app')}`);
+        console.log(`  ${pc.cyan('npm run mobile')}`);
+        console.log('');
+    }
+    if (platforms.includes('api')) {
+        console.log(`  ${pc.gray('# Deploy API')}`);
+        console.log(`  ${pc.cyan('npm run cdk:deploy')}`);
+        console.log('');
+    }
+    console.log(pc.gray('Happy coding!'));
+}
+/**
+ * Parse command line arguments and run the CLI
+ */
+export async function run() {
+    const args = process.argv.slice(2);
+    // Check for --help or -h
+    if (args.includes('--help') || args.includes('-h')) {
+        printHelp();
+        process.exit(0);
+    }
+    // Check for --version or -v
+    if (args.includes('--version') || args.includes('-v')) {
+        console.log(getVersion());
+        process.exit(0);
+    }
+    // Check for subcommands (first non-flag argument)
+    const command = args.find((arg) => !arg.startsWith('-'));
+    // Handle setup-github command
+    if (command === 'setup-github') {
+        await runSetupGitHub();
+        process.exit(0);
+    }
+    // Default: run interactive wizard
+    printWelcome();
+    console.log(''); // blank line after banner
+    const config = await runWizard();
+    if (!config) {
+        console.log('\nProject creation cancelled.');
+        process.exit(1);
+    }
+    // Set up AWS Organizations if enabled
+    if (config.org?.enabled) {
+        console.log('');
+        console.log(pc.cyan('Setting up AWS Organizations...'));
+        try {
+            const orgClient = createOrganizationsClient(config.awsRegion);
+            // Check if already in an organization
+            const existingOrgId = await checkExistingOrganization(orgClient);
+            if (existingOrgId) {
+                console.log(pc.yellow(`Already in organization: ${existingOrgId}`));
+                console.log(pc.dim('Proceeding with existing organization...'));
+            }
+            else {
+                // Create new organization
+                console.log(pc.dim('Creating new AWS Organization...'));
+                const orgId = await createOrganization(orgClient);
+                console.log(pc.green('✔') + ` Organization created: ${orgId}`);
+            }
+            // Create environment accounts
+            const accountResults = await createEnvironmentAccounts(orgClient, config.org.organizationName, config.org.accounts);
+            // Update config.org.accounts with returned accountIds
+            for (const result of accountResults) {
+                const account = config.org.accounts.find((a) => a.environment === result.environment);
+                if (account) {
+                    account.accountId = result.accountId;
+                }
+            }
+            console.log('');
+            console.log(pc.green('✔') + ' AWS Organizations setup complete');
+            console.log(pc.dim('Account IDs:'));
+            for (const account of config.org.accounts) {
+                console.log(pc.dim(`  ${account.environment}: ${account.accountId}`));
+            }
+        }
+        catch (error) {
+            console.log('');
+            // Handle specific AWS errors
+            if (error instanceof Error) {
+                if (error.name === 'CredentialsProviderError' ||
+                    error.message.includes('Could not load credentials')) {
+                    console.log(pc.red('Error:') + ' AWS credentials not configured.');
+                    console.log('');
+                    console.log('Please configure AWS credentials using one of these methods:');
+                    console.log('  1. Run: ' + pc.cyan('aws configure'));
+                    console.log('  2. Set environment variables: ' + pc.cyan('AWS_ACCESS_KEY_ID') + ' and ' + pc.cyan('AWS_SECRET_ACCESS_KEY'));
+                    console.log('  3. Use an AWS profile: ' + pc.cyan('export AWS_PROFILE=your-profile'));
+                    process.exit(1);
+                }
+                if (error.name === 'AccessDeniedException' ||
+                    error.message.includes('not authorized')) {
+                    console.log(pc.red('Error:') + ' Insufficient AWS permissions.');
+                    console.log('');
+                    console.log('Required IAM permissions for AWS Organizations:');
+                    console.log('  - ' + pc.cyan('organizations:CreateOrganization'));
+                    console.log('  - ' + pc.cyan('organizations:DescribeOrganization'));
+                    console.log('  - ' + pc.cyan('organizations:CreateAccount'));
+                    console.log('  - ' + pc.cyan('organizations:DescribeCreateAccountStatus'));
+                    process.exit(1);
+                }
+                // Log which account failed if it's an account creation error
+                if (error.message.includes('Failed to create')) {
+                    console.log(pc.red('Error:') + ` ${error.message}`);
+                    process.exit(1);
+                }
+            }
+            // Generic error
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            console.log(pc.red('Error:') + ` AWS Organizations setup failed: ${message}`);
+            process.exit(1);
+        }
+    }
+    // Determine output directory
+    const outputDir = resolve(process.cwd(), config.projectName);
+    // Check if directory already exists
+    if (existsSync(outputDir)) {
+        console.log('');
+        console.log(pc.red('Error:') + ` Directory ${pc.cyan(config.projectName)} already exists.`);
+        console.log('Please choose a different project name or remove the existing directory.');
+        process.exit(1);
+    }
+    // Create project directory
+    mkdirSync(outputDir, { recursive: true });
+    // Generate project
+    console.log('');
+    await generateProject(config, outputDir);
+    // Success message and next steps
+    console.log('');
+    console.log(pc.green('✔') + ` Created ${pc.bold(config.projectName)} successfully!`);
+    printNextSteps(config.projectName, config.platforms);
+    process.exit(0);
+}

package/dist/commands/setup-github.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Runs the setup-github command
+ */
+export declare function runSetupGitHub(): Promise<void>;

package/dist/commands/setup-github.js

@@ -0,0 +1,185 @@
+import pc from 'picocolors';
+import { fromIni } from '@aws-sdk/credential-providers';
+import { IAMClient } from '@aws-sdk/client-iam';
+import { runGitHubSetupWizard } from '../prompts/github-setup.js';
+import { createDeploymentUserWithCredentials } from '../aws/iam.js';
+import { createGitHubClient, setEnvironmentCredentials } from '../github/secrets.js';
+/**
+ * setup-github command module
+ *
+ * Orchestrates the complete flow of creating IAM deployment users
+ * and configuring GitHub repository secrets for each environment.
+ */
+/**
+ * Prints the setup-github command banner
+ */
+function printBanner() {
+    console.log(`
+${pc.cyan('=================================================')}
+${pc.cyan('          GitHub Deployment Setup')}
+${pc.cyan('=================================================')}
+
+This command will:
+1. Create IAM deployment users in each AWS account
+2. Configure GitHub repository secrets for CI/CD
+
+${pc.dim('Prerequisites:')}
+${pc.dim('- AWS CLI profiles configured for each account')}
+${pc.dim('- GitHub PAT with "repo" scope')}
+`);
+}
+/**
+ * Creates an IAM client configured with credentials from a specific profile
+ * @param region - AWS region
+ * @param profile - AWS CLI profile name
+ * @returns Configured IAMClient
+ */
+function createIAMClientWithProfile(region, profile) {
+    return new IAMClient({
+        region,
+        credentials: fromIni({ profile }),
+    });
+}
+/**
+ * Sets up deployment for a single environment
+ * @param config - Complete setup configuration
+ * @param envConfig - Configuration for this specific environment
+ * @returns Setup result
+ */
+async function setupEnvironment(config, envConfig) {
+    const { environment, accountId, awsProfile } = envConfig;
+    const { projectName, awsRegion, github } = config;
+    console.log(pc.cyan(`\n${'='.repeat(50)}`));
+    console.log(pc.cyan(`Setting up ${pc.bold(environment)} environment`));
+    console.log(pc.cyan('='.repeat(50)));
+    console.log(pc.dim(`Account: ${accountId}`));
+    console.log(pc.dim(`Profile: ${awsProfile}`));
+    try {
+        // Step 1: Create IAM client with profile credentials
+        console.log(pc.dim(`\nConnecting to AWS using profile "${awsProfile}"...`));
+        const iamClient = createIAMClientWithProfile(awsRegion, awsProfile);
+        // Step 2: Create deployment user and get credentials
+        const credentials = await createDeploymentUserWithCredentials(iamClient, projectName, environment, accountId);
+        // Step 3: Create GitHub client
+        console.log(pc.dim('\nConnecting to GitHub...'));
+        const githubClient = createGitHubClient(github.token);
+        // Step 4: Set GitHub repository secrets
+        console.log(pc.dim(`Setting GitHub secrets for ${github.owner}/${github.repo}...`));
+        await setEnvironmentCredentials(githubClient, github.owner, github.repo, environment, credentials.accessKeyId, credentials.secretAccessKey);
+        return {
+            environment,
+            success: true,
+            secretsCreated: [
+                'AWS_ACCESS_KEY_ID',
+                'AWS_SECRET_ACCESS_KEY',
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        // Provide helpful error messages for common issues
+        if (errorMessage.includes('Could not load credentials') ||
+            errorMessage.includes('SharedIniFileCredentials') ||
+            errorMessage.includes('Profile') && errorMessage.includes('not found')) {
+            return {
+                environment,
+                success: false,
+                error: `AWS profile "${awsProfile}" not found or invalid. Configure it with: aws configure --profile ${awsProfile}`,
+            };
+        }
+        if (errorMessage.includes('not authorized') ||
+            errorMessage.includes('AccessDenied')) {
+            return {
+                environment,
+                success: false,
+                error: `Insufficient IAM permissions for profile "${awsProfile}". Ensure the profile has IAM admin access.`,
+            };
+        }
+        if (errorMessage.includes('GitHub authentication failed')) {
+            return {
+                environment,
+                success: false,
+                error: 'GitHub authentication failed. Check that your PAT has the "repo" scope.',
+            };
+        }
+        return {
+            environment,
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Prints the final summary of setup results
+ */
+function printSummary(config, results) {
+    console.log(pc.cyan(`\n${'='.repeat(50)}`));
+    console.log(pc.cyan('                   Summary'));
+    console.log(pc.cyan('='.repeat(50)));
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    console.log(`\nGitHub Repository: ${pc.bold(`${config.github.owner}/${config.github.repo}`)}`);
+    console.log(`Project: ${pc.bold(config.projectName)}`);
+    console.log('');
+    if (successful.length > 0) {
+        console.log(pc.green('Successful environments:'));
+        for (const result of successful) {
+            console.log(pc.green(`  ${pc.bold('+')} ${result.environment}`));
+            if (result.secretsCreated) {
+                for (const secret of result.secretsCreated) {
+                    console.log(pc.dim(`      ${secret}`));
+                }
+            }
+        }
+    }
+    if (failed.length > 0) {
+        console.log(pc.red('\nFailed environments:'));
+        for (const result of failed) {
+            console.log(pc.red(`  ${pc.bold('x')} ${result.environment}`));
+            console.log(pc.dim(`      ${result.error}`));
+        }
+    }
+    console.log('');
+    if (failed.length === 0) {
+        console.log(pc.green(pc.bold('All environments configured successfully!')));
+        console.log('');
+        console.log(pc.dim('Your GitHub Actions workflows can now deploy to AWS using environment secrets.'));
+        console.log(pc.dim('Each environment has AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY configured:'));
+        for (const result of successful) {
+            console.log(pc.dim(`  - ${result.environment}`));
+        }
+    }
+    else if (successful.length === 0) {
+        console.log(pc.red(pc.bold('Setup failed for all environments.')));
+        console.log(pc.dim('Please check the error messages above and try again.'));
+    }
+    else {
+        console.log(pc.yellow(pc.bold(`Setup completed with errors (${successful.length}/${results.length} succeeded).`)));
+        console.log(pc.dim('You can re-run this command to retry failed environments.'));
+    }
+}
+/**
+ * Runs the setup-github command
+ */
+export async function runSetupGitHub() {
+    printBanner();
+    // Run the wizard to collect configuration
+    const config = await runGitHubSetupWizard();
+    if (!config) {
+        console.log(pc.yellow('\nSetup cancelled.'));
+        return;
+    }
+    console.log(pc.cyan('\nStarting deployment setup...'));
+    // Process each environment
+    const results = [];
+    for (const envConfig of config.environments) {
+        const result = await setupEnvironment(config, envConfig);
+        results.push(result);
+        // If an environment fails, ask whether to continue
+        if (!result.success && config.environments.indexOf(envConfig) < config.environments.length - 1) {
+            console.log(pc.yellow(`\nEnvironment ${envConfig.environment} failed. Continuing with remaining environments...`));
+        }
+    }
+    // Print summary
+    printSummary(config, results);
+}

package/dist/generator/copy-file.d.ts

@@ -0,0 +1,15 @@
+import type { TokenValues } from '../templates/types.js';
+/**
+ * Copy a single file with token replacement
+ * @param srcPath - Source file path
+ * @param destPath - Destination file path
+ * @param tokens - Token values for replacement
+ */
+export declare function copyFileWithTokens(srcPath: string, destPath: string, tokens: TokenValues): void;
+/**
+ * Recursively copy a directory with token replacement
+ * @param srcDir - Source directory path
+ * @param destDir - Destination directory path
+ * @param tokens - Token values for replacement
+ */
+export declare function copyDirectoryWithTokens(srcDir: string, destDir: string, tokens: TokenValues): void;

package/dist/generator/copy-file.js

@@ -0,0 +1,56 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, copyFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { replaceTokens } from './replace-tokens.js';
+/**
+ * Check if a file should have token replacement (text files only)
+ */
+function shouldReplaceTokens(filename) {
+    const textExtensions = ['.ts', '.tsx', '.js', '.jsx', '.json', '.md', '.yml', '.yaml', '.html', '.css'];
+    const ext = filename.substring(filename.lastIndexOf('.'));
+    return textExtensions.includes(ext);
+}
+/**
+ * Copy a single file with token replacement
+ * @param srcPath - Source file path
+ * @param destPath - Destination file path
+ * @param tokens - Token values for replacement
+ */
+export function copyFileWithTokens(srcPath, destPath, tokens) {
+    // Ensure destination directory exists
+    mkdirSync(dirname(destPath), { recursive: true });
+    if (shouldReplaceTokens(srcPath)) {
+        // Text file - read, replace tokens, write
+        const content = readFileSync(srcPath, 'utf-8');
+        const replaced = replaceTokens(content, tokens);
+        writeFileSync(destPath, replaced, 'utf-8');
+    }
+    else {
+        // Binary file - direct copy
+        copyFileSync(srcPath, destPath);
+    }
+}
+/**
+ * Recursively copy a directory with token replacement
+ * @param srcDir - Source directory path
+ * @param destDir - Destination directory path
+ * @param tokens - Token values for replacement
+ */
+export function copyDirectoryWithTokens(srcDir, destDir, tokens) {
+    mkdirSync(destDir, { recursive: true });
+    const entries = readdirSync(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(srcDir, entry.name);
+        let destName = entry.name;
+        // Handle .template extension - rename back to original
+        if (destName.endsWith('.template')) {
+            destName = destName.replace('.template', '');
+        }
+        const destPath = join(destDir, destName);
+        if (entry.isDirectory()) {
+            copyDirectoryWithTokens(srcPath, destPath, tokens);
+        }
+        else {
+            copyFileWithTokens(srcPath, destPath, tokens);
+        }
+    }
+}

package/dist/generator/generate-project.d.ts

@@ -0,0 +1,14 @@
+import type { ProjectConfig } from '../types.js';
+/**
+ * Options for project generation
+ */
+export interface GenerateOptions {
+    onProgress?: (message: string) => void;
+}
+/**
+ * Generate a project from templates based on user configuration
+ * @param config - User's project configuration from wizard
+ * @param outputDir - Directory where project will be created
+ * @param options - Optional generation options including progress callback
+ */
+export declare function generateProject(config: ProjectConfig, outputDir: string, options?: GenerateOptions): Promise<void>;