create-aws-project 1.2.1

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

@@ -0,0 +1,53 @@
+import type { PromptObject } from 'prompts';
+/**
+ * GitHub setup prompts module
+ *
+ * Provides prompts for the setup-github command to collect
+ * configuration for IAM deployment users and GitHub secrets.
+ */
+/**
+ * Configuration for an environment with AWS profile
+ */
+export interface EnvironmentConfig {
+    environment: string;
+    accountId: string;
+    awsProfile: string;
+}
+/**
+ * Complete configuration from the GitHub setup wizard
+ */
+export interface GitHubSetupConfig {
+    projectName: string;
+    awsRegion: string;
+    environments: EnvironmentConfig[];
+    github: {
+        owner: string;
+        repo: string;
+        token: string;
+    };
+}
+/**
+ * Project name prompt - used as prefix for IAM users
+ */
+export declare const projectNamePrompt: PromptObject;
+/**
+ * AWS region selection prompt
+ */
+export declare const awsRegionPrompt: PromptObject;
+/**
+ * Environments multiselect prompt
+ */
+export declare const environmentsPrompt: PromptObject;
+/**
+ * GitHub repository prompt - accepts various formats
+ */
+export declare const githubRepoPrompt: PromptObject;
+/**
+ * GitHub Personal Access Token prompt
+ */
+export declare const githubTokenPrompt: PromptObject;
+/**
+ * Runs the complete GitHub setup wizard
+ * @returns Configuration object or null if cancelled
+ */
+export declare function runGitHubSetupWizard(): Promise<GitHubSetupConfig | null>;

package/dist/prompts/github-setup.js

@@ -0,0 +1,208 @@
+import prompts from 'prompts';
+/**
+ * Validates kebab-case project name
+ */
+function isKebabCase(value) {
+    return /^[a-z][a-z0-9-]*[a-z0-9]$/.test(value) || /^[a-z]$/.test(value);
+}
+/**
+ * Project name prompt - used as prefix for IAM users
+ */
+export const projectNamePrompt = {
+    type: 'text',
+    name: 'projectName',
+    message: 'Project name (used as prefix for IAM users):',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Project name is required';
+        if (value.length > 20)
+            return 'Project name must be 20 characters or less';
+        if (!isKebabCase(value))
+            return 'Project name must be kebab-case (e.g., my-app)';
+        return true;
+    },
+    format: (value) => value.trim().toLowerCase(),
+};
+/**
+ * AWS region selection prompt
+ */
+export const awsRegionPrompt = {
+    type: 'select',
+    name: 'awsRegion',
+    message: 'AWS Region:',
+    choices: [
+        { title: 'US East (N. Virginia) - us-east-1', value: 'us-east-1' },
+        { title: 'US West (Oregon) - us-west-2', value: 'us-west-2' },
+        { title: 'EU (Ireland) - eu-west-1', value: 'eu-west-1' },
+        { title: 'EU (Frankfurt) - eu-central-1', value: 'eu-central-1' },
+        { title: 'Asia Pacific (Tokyo) - ap-northeast-1', value: 'ap-northeast-1' },
+        { title: 'Asia Pacific (Sydney) - ap-southeast-2', value: 'ap-southeast-2' },
+    ],
+    initial: 0,
+};
+/**
+ * Environments multiselect prompt
+ */
+export const environmentsPrompt = {
+    type: 'multiselect',
+    name: 'environments',
+    message: 'Select environments to configure:',
+    choices: [
+        { title: 'dev', value: 'dev', selected: true },
+        { title: 'stage', value: 'stage', selected: true },
+        { title: 'prod', value: 'prod', selected: true },
+    ],
+    hint: '- Space to toggle, Enter to confirm',
+    min: 1,
+};
+/**
+ * Validates 12-digit AWS account ID
+ */
+function isValidAccountId(value) {
+    return /^\d{12}$/.test(value);
+}
+/**
+ * Creates account ID prompt for a specific environment
+ */
+function createAccountIdPrompt(environment) {
+    return {
+        type: 'text',
+        name: `accountId_${environment}`,
+        message: `AWS Account ID for ${environment}:`,
+        validate: (value) => {
+            if (!value.trim())
+                return 'Account ID is required';
+            if (!isValidAccountId(value.trim()))
+                return 'Account ID must be a 12-digit number';
+            return true;
+        },
+        format: (value) => value.trim(),
+    };
+}
+/**
+ * Creates AWS profile prompt for a specific environment
+ */
+function createAwsProfilePrompt(environment) {
+    return {
+        type: 'text',
+        name: `awsProfile_${environment}`,
+        message: `AWS profile for ${environment} account:`,
+        initial: 'default',
+        format: (value) => value.trim() || 'default',
+    };
+}
+/**
+ * GitHub repository prompt - accepts various formats
+ */
+export const githubRepoPrompt = {
+    type: 'text',
+    name: 'githubRepo',
+    message: 'GitHub repository (owner/repo or URL):',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Repository is required';
+        // Try to parse the URL to validate format
+        const trimmed = value.trim();
+        const cleanUrl = trimmed.replace(/\/$/, '').replace(/\.git$/, '');
+        // Check supported formats
+        const httpsMatch = cleanUrl.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)$/);
+        const sshMatch = cleanUrl.match(/^git@github\.com:([^/]+)\/([^/]+)$/);
+        const shortMatch = cleanUrl.match(/^([^/]+)\/([^/]+)$/);
+        if (!httpsMatch && !sshMatch && !shortMatch) {
+            return 'Invalid format. Use: owner/repo, https://github.com/owner/repo, or git@github.com:owner/repo';
+        }
+        return true;
+    },
+    format: (value) => value.trim(),
+};
+/**
+ * GitHub Personal Access Token prompt
+ */
+export const githubTokenPrompt = {
+    type: 'password',
+    name: 'githubToken',
+    message: 'GitHub Personal Access Token (requires "repo" scope):',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Token is required';
+        return true;
+    },
+};
+/**
+ * Parses GitHub repository string to owner/repo
+ */
+function parseGitHubRepo(url) {
+    const cleanUrl = url.trim().replace(/\/$/, '').replace(/\.git$/, '');
+    // Format: https://github.com/owner/repo
+    const httpsMatch = cleanUrl.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)$/);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2] };
+    }
+    // Format: git@github.com:owner/repo
+    const sshMatch = cleanUrl.match(/^git@github\.com:([^/]+)\/([^/]+)$/);
+    if (sshMatch) {
+        return { owner: sshMatch[1], repo: sshMatch[2] };
+    }
+    // Format: owner/repo
+    const shortMatch = cleanUrl.match(/^([^/]+)\/([^/]+)$/);
+    if (shortMatch) {
+        return { owner: shortMatch[1], repo: shortMatch[2] };
+    }
+    throw new Error(`Unable to parse GitHub URL: ${url}`);
+}
+/**
+ * Runs the complete GitHub setup wizard
+ * @returns Configuration object or null if cancelled
+ */
+export async function runGitHubSetupWizard() {
+    let cancelled = false;
+    const onCancel = () => {
+        cancelled = true;
+        return false;
+    };
+    // Step 1: Basic configuration
+    const basicResponse = await prompts([projectNamePrompt, awsRegionPrompt, environmentsPrompt], { onCancel });
+    if (cancelled || !basicResponse.projectName || !basicResponse.environments?.length) {
+        return null;
+    }
+    const selectedEnvironments = basicResponse.environments;
+    // Step 2: Account IDs and AWS profiles for each environment
+    const environmentPrompts = [];
+    for (const env of selectedEnvironments) {
+        environmentPrompts.push(createAccountIdPrompt(env));
+        environmentPrompts.push(createAwsProfilePrompt(env));
+    }
+    const environmentResponse = await prompts(environmentPrompts, { onCancel });
+    if (cancelled) {
+        return null;
+    }
+    // Validate all environment data was collected
+    for (const env of selectedEnvironments) {
+        if (!environmentResponse[`accountId_${env}`]) {
+            return null;
+        }
+    }
+    // Step 3: GitHub configuration
+    const githubResponse = await prompts([githubRepoPrompt, githubTokenPrompt], { onCancel });
+    if (cancelled || !githubResponse.githubRepo || !githubResponse.githubToken) {
+        return null;
+    }
+    // Parse GitHub repo
+    const { owner, repo } = parseGitHubRepo(githubResponse.githubRepo);
+    // Build environments array
+    const environments = selectedEnvironments.map((env) => ({
+        environment: env,
+        accountId: environmentResponse[`accountId_${env}`],
+        awsProfile: environmentResponse[`awsProfile_${env}`] || 'default',
+    }));
+    return {
+        projectName: basicResponse.projectName,
+        awsRegion: basicResponse.awsRegion,
+        environments,
+        github: {
+            owner,
+            repo,
+            token: githubResponse.githubToken,
+        },
+    };
+}

package/dist/prompts/org-structure.d.ts

@@ -0,0 +1,9 @@
+import type { PromptObject } from 'prompts';
+export declare const enableOrgPrompt: PromptObject;
+export declare const orgNamePrompt: PromptObject;
+export declare const orgEnvironmentsPrompt: PromptObject;
+export declare const devEmailPrompt: PromptObject;
+export declare const stageEmailPrompt: PromptObject;
+export declare const prodEmailPrompt: PromptObject;
+export declare const qaEmailPrompt: PromptObject;
+export declare const sandboxEmailPrompt: PromptObject;

package/dist/prompts/org-structure.js

@@ -0,0 +1,93 @@
+import pc from 'picocolors';
+export const enableOrgPrompt = {
+    type: 'select',
+    name: 'enableOrg',
+    message: 'Set up AWS Organizations with separate accounts per environment?',
+    choices: [
+        { title: `${pc.yellow('○')} No (single account)`, value: false },
+        { title: `${pc.cyan('◆')} Yes (multi-account)`, value: true },
+    ],
+    initial: 0,
+    hint: '- Creates separate AWS accounts for each environment'
+};
+export const orgNamePrompt = {
+    type: (prev) => prev ? 'text' : null,
+    name: 'orgName',
+    message: 'Organization name:',
+    initial: (_prev, values) => `${values.projectName}-org`,
+    validate: (value) => value.trim().length > 0 || 'Organization name is required'
+};
+export const orgEnvironmentsPrompt = {
+    type: (_prev, values) => values.enableOrg ? 'multiselect' : null,
+    name: 'orgEnvironments',
+    message: 'Select environments to create accounts for:',
+    choices: [
+        { title: 'dev', value: 'dev', selected: true },
+        { title: 'stage', value: 'stage', selected: true },
+        { title: 'prod', value: 'prod', selected: true },
+        { title: 'qa', value: 'qa', selected: false },
+        { title: 'sandbox', value: 'sandbox', selected: false },
+    ],
+    hint: '- Space to toggle, Enter to confirm',
+    min: 1
+};
+export const devEmailPrompt = {
+    type: (_prev, values) => values.enableOrg && values.orgEnvironments?.includes('dev') ? 'text' : null,
+    name: 'devEmail',
+    message: 'Dev account root email:',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Email is required';
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return 'Invalid email format';
+        return true;
+    }
+};
+export const stageEmailPrompt = {
+    type: (_prev, values) => values.enableOrg && values.orgEnvironments?.includes('stage') ? 'text' : null,
+    name: 'stageEmail',
+    message: 'Stage account root email:',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Email is required';
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return 'Invalid email format';
+        return true;
+    }
+};
+export const prodEmailPrompt = {
+    type: (_prev, values) => values.enableOrg && values.orgEnvironments?.includes('prod') ? 'text' : null,
+    name: 'prodEmail',
+    message: 'Prod account root email:',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Email is required';
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return 'Invalid email format';
+        return true;
+    }
+};
+export const qaEmailPrompt = {
+    type: (_prev, values) => values.enableOrg && values.orgEnvironments?.includes('qa') ? 'text' : null,
+    name: 'qaEmail',
+    message: 'QA account root email:',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Email is required';
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return 'Invalid email format';
+        return true;
+    }
+};
+export const sandboxEmailPrompt = {
+    type: (_prev, values) => values.enableOrg && values.orgEnvironments?.includes('sandbox') ? 'text' : null,
+    name: 'sandboxEmail',
+    message: 'Sandbox account root email:',
+    validate: (value) => {
+        if (!value.trim())
+            return 'Email is required';
+        if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value))
+            return 'Invalid email format';
+        return true;
+    }
+};

package/dist/prompts/platforms.d.ts

@@ -0,0 +1,2 @@
+import type { PromptObject } from 'prompts';
+export declare const platformsPrompt: PromptObject;

package/dist/prompts/platforms.js

@@ -0,0 +1,12 @@
+export const platformsPrompt = {
+    type: 'multiselect',
+    name: 'platforms',
+    message: 'Select platforms (space to toggle, enter to confirm):',
+    choices: [
+        { title: 'Web (React + Vite + Chakra UI)', value: 'web', selected: true },
+        { title: 'Mobile (React Native + Expo)', value: 'mobile' },
+        { title: 'API (AWS Lambda + DynamoDB)', value: 'api', selected: true }
+    ],
+    min: 1,
+    hint: '- At least one required'
+};

package/dist/prompts/project-name.d.ts

@@ -0,0 +1,2 @@
+import type { PromptObject } from 'prompts';
+export declare const projectNamePrompt: PromptObject;

package/dist/prompts/project-name.js

@@ -0,0 +1,8 @@
+import { validateProjectName } from '../validation/project-name.js';
+export const projectNamePrompt = {
+    type: 'text',
+    name: 'projectName',
+    message: 'Project name:',
+    initial: 'my-aws-app',
+    validate: (value) => validateProjectName(value)
+};

package/dist/prompts/theme.d.ts

@@ -0,0 +1,2 @@
+import type { PromptObject } from 'prompts';
+export declare const themePrompt: PromptObject;

package/dist/prompts/theme.js

@@ -0,0 +1,14 @@
+import pc from 'picocolors';
+export const themePrompt = {
+    type: 'select',
+    name: 'brandColor',
+    message: 'Choose your brand color:',
+    choices: [
+        { title: `${pc.blue('●')} Blue`, value: 'blue' },
+        { title: `${pc.magenta('●')} Purple`, value: 'purple' },
+        { title: `${pc.cyan('●')} Teal`, value: 'teal' },
+        { title: `${pc.green('●')} Green`, value: 'green' },
+        { title: `${pc.yellow('●')} Orange`, value: 'orange' }
+    ],
+    initial: 0
+};

package/dist/templates/index.d.ts

@@ -0,0 +1,4 @@
+export { TOKENS, TOKEN_PATTERN } from './tokens.js';
+export type { TokenName } from './tokens.js';
+export type { TokenValues, Platform, TemplateFile, TemplateManifest, DeriveTokenValues, } from './types.js';
+export { deriveTokenValues, templateManifest } from './manifest.js';

package/dist/templates/index.js

@@ -0,0 +1,2 @@
+export { TOKENS, TOKEN_PATTERN } from './tokens.js';
+export { deriveTokenValues, templateManifest } from './manifest.js';

package/dist/templates/manifest.d.ts

@@ -0,0 +1,11 @@
+import type { ProjectConfig } from '../types.js';
+import type { TokenValues, TemplateManifest } from './types.js';
+/**
+ * Derive all token values from user's ProjectConfig
+ */
+export declare function deriveTokenValues(config: ProjectConfig): TokenValues;
+/**
+ * Template manifest defining shared and platform-specific files
+ * This matches the structure in templates/manifest.json
+ */
+export declare const templateManifest: TemplateManifest;

package/dist/templates/manifest.js

@@ -0,0 +1,99 @@
+/**
+ * Convert kebab-case to PascalCase
+ * my-awesome-app -> MyAwesomeApp
+ */
+function toPascalCase(str) {
+    return str
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+/**
+ * Convert kebab-case to Title Case
+ * my-awesome-app -> My Awesome App
+ */
+function toTitleCase(str) {
+    return str
+        .split('-')
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Find account ID for a specific environment name
+ */
+function findAccountIdByEnvironment(accounts, environment) {
+    const account = accounts?.find((a) => a.environment.toLowerCase() === environment.toLowerCase());
+    return account?.accountId ?? '';
+}
+/**
+ * Derive all token values from user's ProjectConfig
+ */
+export function deriveTokenValues(config) {
+    // Build organization accounts JSON for flexible environment handling
+    const orgAccounts = config.org?.accounts?.map((a) => ({
+        environment: a.environment,
+        accountId: a.accountId ?? '',
+    })) ?? [];
+    return {
+        PROJECT_NAME: config.projectName,
+        PROJECT_NAME_PASCAL: toPascalCase(config.projectName),
+        PROJECT_NAME_TITLE: toTitleCase(config.projectName),
+        AWS_REGION: config.awsRegion,
+        PACKAGE_SCOPE: `@${config.projectName}`,
+        BRAND_COLOR: config.brandColor,
+        AUTH_COGNITO: config.auth.provider === 'cognito' ? 'true' : 'false',
+        AUTH_AUTH0: config.auth.provider === 'auth0' ? 'true' : 'false',
+        AUTH_SOCIAL_LOGIN: config.auth.features.includes('social-login') ? 'true' : 'false',
+        AUTH_MFA: config.auth.features.includes('mfa') ? 'true' : 'false',
+        // Organization tokens
+        ORG_ENABLED: config.org?.enabled ? 'true' : 'false',
+        ORG_NAME: config.org?.organizationName ?? '',
+        ORG_ACCOUNTS_JSON: JSON.stringify(orgAccounts),
+        // Common environment account IDs for backward compatibility
+        DEV_ACCOUNT_ID: findAccountIdByEnvironment(config.org?.accounts, 'dev'),
+        STAGE_ACCOUNT_ID: findAccountIdByEnvironment(config.org?.accounts, 'stage'),
+        PROD_ACCOUNT_ID: findAccountIdByEnvironment(config.org?.accounts, 'prod'),
+    };
+}
+/**
+ * Template manifest defining shared and platform-specific files
+ * This matches the structure in templates/manifest.json
+ */
+export const templateManifest = {
+    shared: [
+        { src: 'root/package.json', dest: 'package.json' },
+        { src: 'root/tsconfig.base.json', dest: 'tsconfig.base.json' },
+        { src: 'root/nx.json', dest: 'nx.json' },
+        { src: 'root/jest.preset.js', dest: 'jest.preset.js' },
+        { src: 'root/eslint.config.js', dest: 'eslint.config.js' },
+        { src: 'root/.npmrc', dest: '.npmrc' },
+        { src: 'root/.nvmrc', dest: '.nvmrc' },
+        { src: 'root/.editorconfig', dest: '.editorconfig' },
+        { src: 'root/.gitignore', dest: '.gitignore' },
+        { src: 'packages/common-types', dest: 'packages/common-types' },
+        { src: 'packages/api-client', dest: 'packages/api-client' },
+    ],
+    byPlatform: {
+        web: [{ src: 'apps/web', dest: 'apps/web' }],
+        mobile: [{ src: 'apps/mobile', dest: 'apps/mobile' }],
+        api: [{ src: 'apps/api', dest: 'apps/api' }],
+    },
+    byFeature: {
+        'github-actions': [{ src: '.github', dest: '.github' }],
+        'vscode-config': [{ src: '.vscode', dest: '.vscode' }],
+    },
+    byAuthProvider: {
+        cognito: [
+            { src: 'apps/api/cdk/auth', dest: 'apps/api/cdk/auth' },
+            { src: 'apps/web/src/auth/cognito-provider.tsx', dest: 'apps/web/src/auth/cognito-provider.tsx' },
+            { src: 'apps/web/src/config/amplify-config.ts', dest: 'apps/web/src/config/amplify-config.ts' },
+            { src: 'apps/api/src/middleware/cognito-auth.ts', dest: 'apps/api/src/middleware/cognito-auth.ts' },
+        ],
+        auth0: [
+            { src: 'apps/web/src/auth/auth0-provider.tsx', dest: 'apps/web/src/auth/auth0-provider.tsx' },
+            { src: 'apps/web/src/config/auth0-config.ts', dest: 'apps/web/src/config/auth0-config.ts' },
+            { src: 'apps/api/src/middleware/auth0-auth.ts', dest: 'apps/api/src/middleware/auth0-auth.ts' },
+        ],
+        none: [],
+    },
+};

package/dist/templates/tokens.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Template Token Constants
+ *
+ * Placeholder tokens used throughout template files for project customization.
+ * Uses double-brace syntax {{TOKEN}} because:
+ * - Distinct from JS template literals (${}), EJS (<%%>), Mustache ({{}})
+ * - Easy to search/replace with simple regex
+ * - Visible in any file type (JSON, TS, MD)
+ */
+export declare const TOKENS: {
+    /** Project name in kebab-case (e.g., my-awesome-app) */
+    readonly PROJECT_NAME: "{{PROJECT_NAME}}";
+    /** Project name in PascalCase for class names, stack names (e.g., MyAwesomeApp) */
+    readonly PROJECT_NAME_PASCAL: "{{PROJECT_NAME_PASCAL}}";
+    /** Project name in Title Case for display (e.g., My Awesome App) */
+    readonly PROJECT_NAME_TITLE: "{{PROJECT_NAME_TITLE}}";
+    /** AWS region (e.g., us-east-1) */
+    readonly AWS_REGION: "{{AWS_REGION}}";
+    /** Package scope derived from project name (e.g., @my-awesome-app) */
+    readonly PACKAGE_SCOPE: "{{PACKAGE_SCOPE}}";
+    /** Brand color for theme (e.g., blue, purple, teal, green, orange) */
+    readonly BRAND_COLOR: "{{BRAND_COLOR}}";
+    /** Organization enabled flag ('true' or 'false') */
+    readonly ORG_ENABLED: "{{ORG_ENABLED}}";
+    /** Organization name */
+    readonly ORG_NAME: "{{ORG_NAME}}";
+    /** JSON array of {environment, accountId} objects for flexible environment handling */
+    readonly ORG_ACCOUNTS_JSON: "{{ORG_ACCOUNTS_JSON}}";
+    /** Development environment AWS Account ID (empty if not selected) */
+    readonly DEV_ACCOUNT_ID: "{{DEV_ACCOUNT_ID}}";
+    /** Staging environment AWS Account ID (empty if not selected) */
+    readonly STAGE_ACCOUNT_ID: "{{STAGE_ACCOUNT_ID}}";
+    /** Production environment AWS Account ID (empty if not selected) */
+    readonly PROD_ACCOUNT_ID: "{{PROD_ACCOUNT_ID}}";
+};
+/** Regex pattern to match any {{TOKEN_NAME}} placeholder */
+export declare const TOKEN_PATTERN: RegExp;
+/** Type representing valid token names */
+export type TokenName = keyof typeof TOKENS;

package/dist/templates/tokens.js

@@ -0,0 +1,37 @@
+/**
+ * Template Token Constants
+ *
+ * Placeholder tokens used throughout template files for project customization.
+ * Uses double-brace syntax {{TOKEN}} because:
+ * - Distinct from JS template literals (${}), EJS (<%%>), Mustache ({{}})
+ * - Easy to search/replace with simple regex
+ * - Visible in any file type (JSON, TS, MD)
+ */
+export const TOKENS = {
+    /** Project name in kebab-case (e.g., my-awesome-app) */
+    PROJECT_NAME: '{{PROJECT_NAME}}',
+    /** Project name in PascalCase for class names, stack names (e.g., MyAwesomeApp) */
+    PROJECT_NAME_PASCAL: '{{PROJECT_NAME_PASCAL}}',
+    /** Project name in Title Case for display (e.g., My Awesome App) */
+    PROJECT_NAME_TITLE: '{{PROJECT_NAME_TITLE}}',
+    /** AWS region (e.g., us-east-1) */
+    AWS_REGION: '{{AWS_REGION}}',
+    /** Package scope derived from project name (e.g., @my-awesome-app) */
+    PACKAGE_SCOPE: '{{PACKAGE_SCOPE}}',
+    /** Brand color for theme (e.g., blue, purple, teal, green, orange) */
+    BRAND_COLOR: '{{BRAND_COLOR}}',
+    /** Organization enabled flag ('true' or 'false') */
+    ORG_ENABLED: '{{ORG_ENABLED}}',
+    /** Organization name */
+    ORG_NAME: '{{ORG_NAME}}',
+    /** JSON array of {environment, accountId} objects for flexible environment handling */
+    ORG_ACCOUNTS_JSON: '{{ORG_ACCOUNTS_JSON}}',
+    /** Development environment AWS Account ID (empty if not selected) */
+    DEV_ACCOUNT_ID: '{{DEV_ACCOUNT_ID}}',
+    /** Staging environment AWS Account ID (empty if not selected) */
+    STAGE_ACCOUNT_ID: '{{STAGE_ACCOUNT_ID}}',
+    /** Production environment AWS Account ID (empty if not selected) */
+    PROD_ACCOUNT_ID: '{{PROD_ACCOUNT_ID}}',
+};
+/** Regex pattern to match any {{TOKEN_NAME}} placeholder */
+export const TOKEN_PATTERN = /\{\{([A-Z_]+)\}\}/g;

package/dist/templates/types.d.ts

@@ -0,0 +1,52 @@
+import type { ProjectConfig, Feature, AuthProvider } from '../types.js';
+/** Mapping of token names to their replacement values */
+export interface TokenValues {
+    PROJECT_NAME: string;
+    PROJECT_NAME_PASCAL: string;
+    PROJECT_NAME_TITLE: string;
+    AWS_REGION: string;
+    PACKAGE_SCOPE: string;
+    BRAND_COLOR: string;
+    AUTH_COGNITO: string;
+    AUTH_AUTH0: string;
+    AUTH_SOCIAL_LOGIN: string;
+    AUTH_MFA: string;
+    /** Organization enabled flag ('true' or 'false') */
+    ORG_ENABLED?: string;
+    /** Organization name */
+    ORG_NAME?: string;
+    /** JSON array of {environment, accountId} objects for templates needing full list */
+    ORG_ACCOUNTS_JSON?: string;
+    /** Development environment AWS Account ID (empty if not selected) */
+    DEV_ACCOUNT_ID?: string;
+    /** Staging environment AWS Account ID (empty if not selected) */
+    STAGE_ACCOUNT_ID?: string;
+    /** Production environment AWS Account ID (empty if not selected) */
+    PROD_ACCOUNT_ID?: string;
+}
+/** Platform identifiers for conditional templates */
+export type Platform = 'web' | 'mobile' | 'api';
+/** A single template file entry */
+export interface TemplateFile {
+    /** Source path relative to templates/ directory */
+    src: string;
+    /** Destination path relative to output directory (may contain tokens) */
+    dest: string;
+    /** Which platforms this file belongs to (undefined = all platforms) */
+    platforms?: Platform[];
+}
+/** Complete template manifest */
+export interface TemplateManifest {
+    /** Files that are always included */
+    shared: TemplateFile[];
+    /** Files grouped by platform */
+    byPlatform: Record<Platform, TemplateFile[]>;
+    /** Files grouped by feature */
+    byFeature: Record<Feature, TemplateFile[]>;
+    /** Files grouped by auth provider */
+    byAuthProvider: Record<AuthProvider, TemplateFile[]>;
+}
+/** Function to derive token values from ProjectConfig */
+export type DeriveTokenValues = (config: ProjectConfig) => TokenValues;
+/** Re-export Feature and AuthProvider types for convenience */
+export type { Feature, AuthProvider };

package/dist/templates/types.js

@@ -0,0 +1 @@
+export {};