create-aws-project 1.2.1

package/README.md

@@ -0,0 +1,118 @@
+# create-aws-project
+
+Create a new AWS project from scratch including CloudFront, API Gateway, Lambdas, Cognito or Auth0, DynamoDB. GitHub pipeline for testing and deploying.
+
+[![npm version](https://img.shields.io/npm/v/create-aws-starter-kit.svg)](https://www.npmjs.com/package/create-aws-starter-kit)
+
+## Quick Start
+
+```bash
+npx create-aws-starter-kit my-project
+```
+
+**Requirements:** Node.js 22.16.0+ (npm included)
+
+## Features
+
+- **Interactive wizard** - Guided setup with smart defaults
+- **Platform selection** - Choose web, mobile, and/or API
+- **Feature toggles** - GitHub Actions CI/CD, VS Code configuration
+- **Theme customization** - Choose a brand color for your UI
+- **AWS region configuration** - Set your deployment region
+
+## What You Get
+
+The generated project is a full-stack Nx monorepo with:
+
+- **React web app** - Vite + Chakra UI
+- **React Native mobile app** - Expo
+- **AWS Lambda API** - TypeScript handlers
+- **AWS CDK infrastructure** - Infrastructure as code
+- **Shared packages** - Common types and API client
+
+## CLI Options
+
+```
+create-aws-starter-kit [options] [project-name]
+
+Options:
+  --help, -h      Show help message
+  --version, -v   Show version number
+
+Examples:
+  npx create-aws-starter-kit my-app
+  npx create-aws-starter-kit --help
+  npx create-aws-starter-kit --version
+```
+
+### Setup GitHub Command
+
+After generating a project with AWS Organizations enabled, configure GitHub Actions deployment:
+
+```bash
+npx create-aws-starter-kit setup-github
+```
+
+This command:
+- Creates IAM deployment users per environment (dev, stage, prod)
+- Configures GitHub Environments with AWS credentials
+- Sets up least-privilege CDK deployment permissions
+
+**Requirements:**
+- GitHub Personal Access Token with `repo` and `admin:org` scopes
+- AWS credentials with IAM permissions
+
+## Wizard Prompts
+
+The interactive wizard will ask you about:
+
+1. **Project name** - Must be npm-compatible (lowercase, no spaces)
+2. **Platforms** - Which platforms to include (web, mobile, api)
+3. **Authentication** - Choose your auth provider:
+   - None (add later)
+   - AWS Cognito
+   - Auth0
+   - Optional: Social login, MFA
+4. **AWS Organizations** - Multi-account setup (optional):
+   - Creates separate AWS accounts for each environment
+   - Environments: dev, stage, prod (plus optional qa, sandbox)
+   - Requires root email per account
+5. **Features** - Optional extras:
+   - GitHub Actions workflows for CI/CD
+   - VS Code workspace configuration
+6. **AWS region** - Where to deploy your infrastructure
+7. **Brand color** - Theme color for your UI (blue, purple, teal, green, orange)
+
+## Requirements
+
+- **Node.js** - Version 22.16.0 or higher
+  - Note: Node 25+ has Jest compatibility issues - use 22.x or 24.x
+- **npm** - Included with Node.js
+
+## After Generation
+
+Once your project is created:
+
+```bash
+cd my-project
+npm install
+```
+
+Then start developing:
+
+```bash
+# Start web app
+npm run web
+
+# Start mobile app
+npm run mobile
+
+# Deploy API to AWS
+npm run cdk:deploy
+```
+
+See the generated project's README for detailed documentation.
+
+## License
+
+ISC

package/dist/__tests__/generator/replace-tokens.spec.d.ts

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

package/dist/__tests__/generator/replace-tokens.spec.js

@@ -0,0 +1,281 @@
+import { describe, it, expect } from '@jest/globals';
+import { replaceTokens, processConditionalBlocks, } from '../../generator/replace-tokens.js';
+describe('replaceTokens', () => {
+    const mockTokens = {
+        PROJECT_NAME: 'my-awesome-app',
+        PROJECT_NAME_PASCAL: 'MyAwesomeApp',
+        PROJECT_NAME_TITLE: 'My Awesome App',
+        AWS_REGION: 'us-west-2',
+        PACKAGE_SCOPE: '@my-awesome-app',
+        BRAND_COLOR: 'blue',
+        AUTH_COGNITO: 'false',
+        AUTH_AUTH0: 'false',
+        AUTH_SOCIAL_LOGIN: 'false',
+        AUTH_MFA: 'false',
+    };
+    describe('single token replacement', () => {
+        it('should replace PROJECT_NAME token', () => {
+            const content = 'name: {{PROJECT_NAME}}';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('name: my-awesome-app');
+        });
+        it('should replace PROJECT_NAME_PASCAL token', () => {
+            const content = 'class {{PROJECT_NAME_PASCAL}}Stack {}';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('class MyAwesomeAppStack {}');
+        });
+        it('should replace AWS_REGION token', () => {
+            const content = 'region: {{AWS_REGION}}';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('region: us-west-2');
+        });
+        it('should replace PACKAGE_SCOPE token', () => {
+            const content = "import { User } from '{{PACKAGE_SCOPE}}/common-types';";
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe("import { User } from '@my-awesome-app/common-types';");
+        });
+        it('should replace BRAND_COLOR token', () => {
+            const content = 'color: {{BRAND_COLOR}}';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('color: blue');
+        });
+        it('should replace AUTH_COGNITO token', () => {
+            const content = 'cognito: {{AUTH_COGNITO}}';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('cognito: false');
+        });
+    });
+    describe('multiple token replacement', () => {
+        it('should replace multiple different tokens', () => {
+            const content = `{
+  "name": "{{PROJECT_NAME}}",
+  "region": "{{AWS_REGION}}",
+  "scope": "{{PACKAGE_SCOPE}}"
+}`;
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe(`{
+  "name": "my-awesome-app",
+  "region": "us-west-2",
+  "scope": "@my-awesome-app"
+}`);
+        });
+        it('should replace same token multiple times', () => {
+            const content = '{{PROJECT_NAME}} and {{PROJECT_NAME}} again';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('my-awesome-app and my-awesome-app again');
+        });
+    });
+    describe('unknown token handling', () => {
+        it('should preserve unknown tokens', () => {
+            const content = '{{UNKNOWN_TOKEN}} stays';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('{{UNKNOWN_TOKEN}} stays');
+        });
+        it('should replace known tokens and preserve unknown ones', () => {
+            const content = '{{PROJECT_NAME}} and {{UNKNOWN_TOKEN}}';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('my-awesome-app and {{UNKNOWN_TOKEN}}');
+        });
+    });
+    describe('passthrough for content without tokens', () => {
+        it('should return unchanged content when no tokens present', () => {
+            const content = 'Regular content without any tokens';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('Regular content without any tokens');
+        });
+        it('should return empty string unchanged', () => {
+            const content = '';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('');
+        });
+        it('should not match partial token patterns', () => {
+            const content = '{ PROJECT_NAME } and {{ broken';
+            const result = replaceTokens(content, mockTokens);
+            expect(result).toBe('{ PROJECT_NAME } and {{ broken');
+        });
+    });
+});
+describe('processConditionalBlocks', () => {
+    const baseTokens = {
+        PROJECT_NAME: 'my-awesome-app',
+        PROJECT_NAME_PASCAL: 'MyAwesomeApp',
+        PROJECT_NAME_TITLE: 'My Awesome App',
+        AWS_REGION: 'us-west-2',
+        PACKAGE_SCOPE: '@my-awesome-app',
+        BRAND_COLOR: 'blue',
+        AUTH_COGNITO: 'false',
+        AUTH_AUTH0: 'false',
+        AUTH_SOCIAL_LOGIN: 'false',
+        AUTH_MFA: 'false',
+    };
+    describe('comment-wrapped conditionals', () => {
+        it('should keep content when token is true (removes markers)', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'true' };
+            const content = `before
+// {{#if AUTH_COGNITO}}
+import { CognitoStack } from './cognito';
+// {{/if AUTH_COGNITO}}
+after`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`before
+import { CognitoStack } from './cognito';
+after`);
+        });
+        it('should remove entire block when token is false', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'false' };
+            const content = `before
+// {{#if AUTH_COGNITO}}
+import { CognitoStack } from './cognito';
+// {{/if AUTH_COGNITO}}
+after`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`before
+after`);
+        });
+        it('should remove entire block when token is missing', () => {
+            const content = `before
+// {{#if UNKNOWN_TOKEN}}
+some content
+// {{/if UNKNOWN_TOKEN}}
+after`;
+            const result = processConditionalBlocks(content, baseTokens);
+            expect(result).toBe(`before
+after`);
+        });
+        it('should handle multiple comment-wrapped blocks', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'true', AUTH_AUTH0: 'false' };
+            const content = `// {{#if AUTH_COGNITO}}
+import { CognitoStack } from './cognito';
+// {{/if AUTH_COGNITO}}
+// {{#if AUTH_AUTH0}}
+import { Auth0Stack } from './auth0';
+// {{/if AUTH_AUTH0}}
+const app = new App();`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`import { CognitoStack } from './cognito';
+const app = new App();`);
+        });
+    });
+    describe('plain conditionals', () => {
+        it('should keep content when token is true (removes markers)', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'true' };
+            const content = `before
+{{#if AUTH_COGNITO}}
+Cognito content here
+{{/if AUTH_COGNITO}}
+after`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`before
+Cognito content here
+after`);
+        });
+        it('should remove entire block when token is false', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'false' };
+            const content = `before
+{{#if AUTH_COGNITO}}
+Cognito content here
+{{/if AUTH_COGNITO}}
+after`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`before
+after`);
+        });
+    });
+    describe('nested content with other tokens', () => {
+        it('should preserve tokens inside conditional blocks for later replacement', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'true' };
+            const content = `// {{#if AUTH_COGNITO}}
+new CognitoStack(app, '{{PROJECT_NAME_PASCAL}}-Cognito');
+// {{/if AUTH_COGNITO}}`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`new CognitoStack(app, '{{PROJECT_NAME_PASCAL}}-Cognito');
+`);
+        });
+    });
+    describe('content preservation', () => {
+        it('should preserve content outside of conditional blocks', () => {
+            const tokens = { ...baseTokens, AUTH_COGNITO: 'false' };
+            const content = `const app = new App();
+// {{#if AUTH_COGNITO}}
+new CognitoStack(app);
+// {{/if AUTH_COGNITO}}
+const region = '{{AWS_REGION}}';`;
+            const result = processConditionalBlocks(content, tokens);
+            expect(result).toBe(`const app = new App();
+const region = '{{AWS_REGION}}';`);
+        });
+        it('should return unchanged content when no conditionals present', () => {
+            const content = `const app = new App();
+const region = '{{AWS_REGION}}';`;
+            const result = processConditionalBlocks(content, baseTokens);
+            expect(result).toBe(content);
+        });
+        it('should return empty string unchanged', () => {
+            const result = processConditionalBlocks('', baseTokens);
+            expect(result).toBe('');
+        });
+    });
+});
+describe('replaceTokens integration with conditionals', () => {
+    const baseTokens = {
+        PROJECT_NAME: 'my-awesome-app',
+        PROJECT_NAME_PASCAL: 'MyAwesomeApp',
+        PROJECT_NAME_TITLE: 'My Awesome App',
+        AWS_REGION: 'us-west-2',
+        PACKAGE_SCOPE: '@my-awesome-app',
+        BRAND_COLOR: 'blue',
+        AUTH_COGNITO: 'false',
+        AUTH_AUTH0: 'false',
+        AUTH_SOCIAL_LOGIN: 'false',
+        AUTH_MFA: 'false',
+    };
+    it('should process conditionals before token replacement', () => {
+        const tokens = { ...baseTokens, AUTH_COGNITO: 'true' };
+        const content = `const appName = '{{PROJECT_NAME_PASCAL}}';
+// {{#if AUTH_COGNITO}}
+new CognitoStack(app, '{{PROJECT_NAME_PASCAL}}-Cognito');
+// {{/if AUTH_COGNITO}}`;
+        const result = replaceTokens(content, tokens);
+        expect(result).toBe(`const appName = 'MyAwesomeApp';
+new CognitoStack(app, 'MyAwesomeApp-Cognito');
+`);
+    });
+    it('should handle AUTH_COGNITO=true keeping Cognito-specific code', () => {
+        const tokens = { ...baseTokens, AUTH_COGNITO: 'true' };
+        const content = `import * as cdk from 'aws-cdk-lib';
+// {{#if AUTH_COGNITO}}
+import { CognitoStack } from './auth/cognito-stack';
+// {{/if AUTH_COGNITO}}
+
+const app = new cdk.App();`;
+        const result = replaceTokens(content, tokens);
+        expect(result).toBe(`import * as cdk from 'aws-cdk-lib';
+import { CognitoStack } from './auth/cognito-stack';
+
+const app = new cdk.App();`);
+    });
+    it('should handle AUTH_AUTH0=true keeping Auth0-specific code', () => {
+        const tokens = { ...baseTokens, AUTH_AUTH0: 'true' };
+        const content = `// {{#if AUTH_AUTH0}}
+import { auth0Config } from './auth0-config';
+// {{/if AUTH_AUTH0}}
+export const config = {};`;
+        const result = replaceTokens(content, tokens);
+        expect(result).toBe(`import { auth0Config } from './auth0-config';
+export const config = {};`);
+    });
+    it('should remove auth-specific code when provider is false', () => {
+        const tokens = { ...baseTokens, AUTH_COGNITO: 'false', AUTH_AUTH0: 'false' };
+        const content = `const app = new App();
+// {{#if AUTH_COGNITO}}
+new CognitoStack(app);
+// {{/if AUTH_COGNITO}}
+// {{#if AUTH_AUTH0}}
+new Auth0Integration(app);
+// {{/if AUTH_AUTH0}}
+app.synth();`;
+        const result = replaceTokens(content, tokens);
+        expect(result).toBe(`const app = new App();
+app.synth();`);
+    });
+});

package/dist/__tests__/generator.spec.d.ts

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

package/dist/__tests__/generator.spec.js

@@ -0,0 +1,162 @@
+import { describe, it, expect } from '@jest/globals';
+import { deriveTokenValues, templateManifest } from '../templates/index.js';
+/**
+ * Create a minimal valid ProjectConfig for testing
+ */
+function createMockConfig(overrides = {}) {
+    return {
+        projectName: 'test-project',
+        platforms: ['web', 'api'],
+        awsRegion: 'us-east-1',
+        features: [],
+        brandColor: 'blue',
+        auth: {
+            provider: 'none',
+            features: [],
+        },
+        ...overrides,
+    };
+}
+describe('Generator', () => {
+    describe('templateManifest.byAuthProvider', () => {
+        it('should have Cognito auth templates defined', () => {
+            expect(templateManifest.byAuthProvider.cognito).toBeDefined();
+            expect(Array.isArray(templateManifest.byAuthProvider.cognito)).toBe(true);
+            expect(templateManifest.byAuthProvider.cognito.length).toBeGreaterThan(0);
+        });
+        it('should include cognito auth directory in cognito templates', () => {
+            const cognitoTemplates = templateManifest.byAuthProvider.cognito;
+            const hasAuthDir = cognitoTemplates.some((entry) => entry.src.includes('auth') || entry.dest.includes('auth'));
+            expect(hasAuthDir).toBe(true);
+        });
+        it('should have empty array for none provider', () => {
+            expect(templateManifest.byAuthProvider.none).toBeDefined();
+            expect(Array.isArray(templateManifest.byAuthProvider.none)).toBe(true);
+            expect(templateManifest.byAuthProvider.none.length).toBe(0);
+        });
+        it('should have Auth0 auth templates defined', () => {
+            expect(templateManifest.byAuthProvider.auth0).toBeDefined();
+            expect(Array.isArray(templateManifest.byAuthProvider.auth0)).toBe(true);
+            expect(templateManifest.byAuthProvider.auth0.length).toBeGreaterThan(0);
+        });
+        it('should include Auth0 provider, config, and middleware in auth0 templates', () => {
+            const auth0Templates = templateManifest.byAuthProvider.auth0;
+            const hasProvider = auth0Templates.some((entry) => entry.src.includes('auth0-provider.tsx'));
+            const hasConfig = auth0Templates.some((entry) => entry.src.includes('auth0-config.ts'));
+            const hasMiddleware = auth0Templates.some((entry) => entry.src.includes('auth0-auth.ts'));
+            expect(hasProvider).toBe(true);
+            expect(hasConfig).toBe(true);
+            expect(hasMiddleware).toBe(true);
+        });
+    });
+    describe('deriveTokenValues', () => {
+        it('should set AUTH_COGNITO to true when cognito provider selected', () => {
+            const config = createMockConfig({
+                auth: { provider: 'cognito', features: [] },
+            });
+            const tokens = deriveTokenValues(config);
+            expect(tokens.AUTH_COGNITO).toBe('true');
+            expect(tokens.AUTH_AUTH0).toBe('false');
+        });
+        it('should set AUTH_AUTH0 to true when auth0 provider selected', () => {
+            const config = createMockConfig({
+                auth: { provider: 'auth0', features: [] },
+            });
+            const tokens = deriveTokenValues(config);
+            expect(tokens.AUTH_COGNITO).toBe('false');
+            expect(tokens.AUTH_AUTH0).toBe('true');
+        });
+        it('should set all auth tokens to false when provider is none', () => {
+            const config = createMockConfig({
+                auth: { provider: 'none', features: [] },
+            });
+            const tokens = deriveTokenValues(config);
+            expect(tokens.AUTH_COGNITO).toBe('false');
+            expect(tokens.AUTH_AUTH0).toBe('false');
+            expect(tokens.AUTH_MFA).toBe('false');
+            expect(tokens.AUTH_SOCIAL_LOGIN).toBe('false');
+        });
+        it('should set AUTH_MFA to true when mfa feature enabled', () => {
+            const config = createMockConfig({
+                auth: { provider: 'cognito', features: ['mfa'] },
+            });
+            const tokens = deriveTokenValues(config);
+            expect(tokens.AUTH_MFA).toBe('true');
+        });
+        it('should set AUTH_SOCIAL_LOGIN to true when social-login feature enabled', () => {
+            const config = createMockConfig({
+                auth: { provider: 'cognito', features: ['social-login'] },
+            });
+            const tokens = deriveTokenValues(config);
+            expect(tokens.AUTH_SOCIAL_LOGIN).toBe('true');
+        });
+        it('should set multiple auth feature tokens when multiple features enabled', () => {
+            const config = createMockConfig({
+                auth: { provider: 'cognito', features: ['mfa', 'social-login'] },
+            });
+            const tokens = deriveTokenValues(config);
+            expect(tokens.AUTH_COGNITO).toBe('true');
+            expect(tokens.AUTH_MFA).toBe('true');
+            expect(tokens.AUTH_SOCIAL_LOGIN).toBe('true');
+        });
+        it('should include all auth tokens in the returned object', () => {
+            const config = createMockConfig();
+            const tokens = deriveTokenValues(config);
+            expect('AUTH_COGNITO' in tokens).toBe(true);
+            expect('AUTH_AUTH0' in tokens).toBe(true);
+            expect('AUTH_MFA' in tokens).toBe(true);
+            expect('AUTH_SOCIAL_LOGIN' in tokens).toBe(true);
+        });
+    });
+    describe('auth provider template selection', () => {
+        it('should return templates for cognito when cognito provider selected', () => {
+            const config = createMockConfig({
+                auth: { provider: 'cognito', features: [] },
+            });
+            const authEntries = templateManifest.byAuthProvider[config.auth.provider];
+            expect(authEntries).toBeDefined();
+            expect(authEntries.length).toBeGreaterThan(0);
+        });
+        it('should return empty array when provider is none', () => {
+            const config = createMockConfig({
+                auth: { provider: 'none', features: [] },
+            });
+            const authEntries = templateManifest.byAuthProvider[config.auth.provider];
+            expect(authEntries).toBeDefined();
+            expect(authEntries.length).toBe(0);
+        });
+        it('should skip auth template processing when provider is none', () => {
+            const config = createMockConfig({
+                auth: { provider: 'none', features: [] },
+            });
+            // This tests the logic: if provider !== 'none', we would process templates
+            // Since provider === 'none', we would skip the processing
+            const shouldProcessAuth = config.auth.provider !== 'none';
+            expect(shouldProcessAuth).toBe(false);
+        });
+        it('should process auth templates when provider is cognito', () => {
+            const config = createMockConfig({
+                auth: { provider: 'cognito', features: [] },
+            });
+            // This tests the logic: if provider !== 'none', we should process templates
+            const shouldProcessAuth = config.auth.provider !== 'none';
+            expect(shouldProcessAuth).toBe(true);
+        });
+        it('should return templates for auth0 when auth0 provider selected', () => {
+            const config = createMockConfig({
+                auth: { provider: 'auth0', features: [] },
+            });
+            const authEntries = templateManifest.byAuthProvider[config.auth.provider];
+            expect(authEntries).toBeDefined();
+            expect(authEntries.length).toBeGreaterThan(0);
+        });
+        it('should process auth templates when provider is auth0', () => {
+            const config = createMockConfig({
+                auth: { provider: 'auth0', features: [] },
+            });
+            // This tests the logic: if provider !== 'none', we should process templates
+            const shouldProcessAuth = config.auth.provider !== 'none';
+            expect(shouldProcessAuth).toBe(true);
+        });
+    });
+});

package/dist/__tests__/validation/project-name.spec.d.ts

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

package/dist/__tests__/validation/project-name.spec.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from '@jest/globals';
+import { validateProjectName } from '../../validation/project-name.js';
+describe('validateProjectName', () => {
+    describe('valid names', () => {
+        it('should accept simple kebab-case names', () => {
+            expect(validateProjectName('my-app')).toBe(true);
+        });
+        it('should accept names with numbers', () => {
+            expect(validateProjectName('app123')).toBe(true);
+        });
+        it('should accept names ending with numbers', () => {
+            expect(validateProjectName('my-app-2')).toBe(true);
+        });
+        it('should accept single-word names', () => {
+            expect(validateProjectName('myapp')).toBe(true);
+        });
+        it('should accept names starting with numbers (npm allows this)', () => {
+            expect(validateProjectName('123app')).toBe(true);
+        });
+        it('should accept scoped packages (npm allows this)', () => {
+            expect(validateProjectName('@scope/pkg')).toBe(true);
+        });
+        it('should accept underscores (npm allows this)', () => {
+            expect(validateProjectName('my_app')).toBe(true);
+        });
+    });
+    describe('invalid names', () => {
+        it('should reject names with spaces', () => {
+            const result = validateProjectName('My App');
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+        it('should reject empty string', () => {
+            const result = validateProjectName('');
+            expect(result).toBe('Project name is required');
+        });
+        it('should reject whitespace-only string', () => {
+            const result = validateProjectName('   ');
+            expect(result).toBe('Project name is required');
+        });
+        it('should reject names with uppercase letters', () => {
+            const result = validateProjectName('MyApp');
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+        it('should reject names starting with dot', () => {
+            const result = validateProjectName('.hidden');
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+        it('should reject node_modules as a name', () => {
+            const result = validateProjectName('node_modules');
+            expect(result).not.toBe(true);
+            expect(typeof result).toBe('string');
+        });
+    });
+});

package/dist/__tests__/wizard.spec.d.ts

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