create-aws-project 1.5.0 → 1.5.1

package/README.md

@@ -69,6 +69,7 @@ The interactive wizard will ask you about:
    - 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)
+8. **GitHub repository** *(optional)* - Provide a repo URL to git init, commit, and push automatically. Press Enter to skip.
 
 ## Requirements
 
@@ -84,32 +85,9 @@ After creating your project, you'll set up AWS environments and GitHub deploymen
 
 Before you begin:
 - AWS CLI configured with credentials from your AWS management account
-- GitHub repository created for your project
 - GitHub Personal Access Token with "repo" scope ([create one here](https://github.com/settings/tokens/new))
 
-### Step 1: connect to your .git project
-
-* Initialize the repository
-```
-git init
-```
-
-* Add the remote repository using the git remote add <name> <url> command. A common practice is to name it origin.
-```bash
-git remote add origin <REMOTE_URL>
-```
-
-* Verify the connection by listing your remotes. The -v flag shows the URLs.
-```bash
-git remote -v
-```
-
-* Push your local commits to the remote repository for the first time.
-```bash
-git push -u origin main
-```
-
-### Step 2: Set Up AWS Environments
+### Step 1: Set Up AWS Environments
 
 From your project directory, run:
 
@@ -136,7 +114,7 @@ AWS environment setup complete!
 
 Account IDs are saved to `.aws-starter-config.json` for the next step.
 
-### Step 3: Configure GitHub Environments
+### Step 2: Configure GitHub Environments
 
 For each environment, run:
 

package/dist/cli.js

@@ -7,6 +7,7 @@ import { generateProject } from './generator/index.js';
 import { showDeprecationNotice } from './commands/setup-github.js';
 import { runSetupAwsEnvs } from './commands/setup-aws-envs.js';
 import { runInitializeGitHub } from './commands/initialize-github.js';
+import { promptGitSetup, setupGitRepository } from './git/setup.js';
 /**
  * Write project configuration file for downstream commands
  */
@@ -40,7 +41,7 @@ function getVersion() {
  */
 function printHelp() {
     console.log(`
-create-aws-starter-kit [command] [options]
+create-aws-project [command] [options]
 
 Scaffold a new AWS Starter Kit project with React, Lambda, and CDK infrastructure.
 
@@ -55,15 +56,15 @@ Options:
   --version, -v       Show version number
 
 Usage:
-  create-aws-starter-kit                         Run interactive wizard
-  create-aws-starter-kit setup-aws-envs          Create AWS accounts
-  create-aws-starter-kit initialize-github dev   Configure dev environment
+  create-aws-project                         Run interactive wizard
+  create-aws-project setup-aws-envs          Create AWS accounts
+  create-aws-project initialize-github dev   Configure dev environment
 
 Examples:
-  create-aws-starter-kit my-app
-  create-aws-starter-kit setup-aws-envs
-  create-aws-starter-kit initialize-github dev
-  create-aws-starter-kit --help
+  create-aws-project my-app
+  create-aws-project setup-aws-envs
+  create-aws-project initialize-github dev
+  create-aws-project --help
 `.trim());
 }
 /**
@@ -73,7 +74,7 @@ function printWelcome() {
     console.log(`
 ╔═══════════════════════════════════════════════════════╗
 ║                                                       ║
-║            create-aws-starter-kit                     ║
+║            create-aws-project                     ║
 ║       AWS Starter Kit Project Generator               ║
 ║                                                       ║
 ╚═══════════════════════════════════════════════════════╝
@@ -113,10 +114,12 @@ function printNextSteps(projectName, platforms) {
  * Run the create project wizard flow
  * This is the default command when no subcommand is specified
  */
-async function runCreate(_args) {
+async function runCreate(args) {
     printWelcome();
     console.log(''); // blank line after banner
-    const config = await runWizard();
+    // Extract project name from CLI args (first non-flag argument)
+    const nameArg = args.find(arg => !arg.startsWith('-'));
+    const config = await runWizard(nameArg ? { defaultName: nameArg } : undefined);
     if (!config) {
         console.log('\nProject creation cancelled.');
         process.exit(1);
@@ -137,6 +140,11 @@ async function runCreate(_args) {
     await generateProject(config, outputDir);
     // Write config file for downstream commands
     writeConfigFile(outputDir, config);
+    // Optional: GitHub repository setup
+    const gitResult = await promptGitSetup();
+    if (gitResult) {
+        await setupGitRepository(outputDir, gitResult.repoUrl, gitResult.pat);
+    }
     // Success message and next steps
     console.log('');
     console.log(pc.green('✔') + ` Created ${pc.bold(config.projectName)} successfully!`);

package/dist/git/setup.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Git setup module
+ *
+ * Provides optional GitHub repository setup after project generation.
+ * Users can push their generated project to GitHub in the same wizard flow.
+ * Fully optional - pressing Enter skips all git operations.
+ */
+/**
+ * Checks if git is available on the system
+ * @returns true if git is installed and available, false otherwise
+ */
+export declare function isGitAvailable(): boolean;
+/**
+ * Prompts user for optional GitHub repository setup
+ * @returns Repository URL and PAT if user wants git setup, null if skipped
+ */
+export declare function promptGitSetup(): Promise<{
+    repoUrl: string;
+    pat: string;
+} | null>;
+/**
+ * Sets up git repository with initial commit and pushes to GitHub
+ * Creates the remote repository if it doesn't exist
+ * @param projectDir - Path to the project directory
+ * @param repoUrl - GitHub repository URL
+ * @param pat - GitHub Personal Access Token
+ */
+export declare function setupGitRepository(projectDir: string, repoUrl: string, pat: string): Promise<void>;

package/dist/git/setup.js

@@ -0,0 +1,165 @@
+import { execSync } from 'node:child_process';
+import prompts from 'prompts';
+import ora from 'ora';
+import pc from 'picocolors';
+import { parseGitHubUrl, createGitHubClient } from '../github/secrets.js';
+/**
+ * Git setup module
+ *
+ * Provides optional GitHub repository setup after project generation.
+ * Users can push their generated project to GitHub in the same wizard flow.
+ * Fully optional - pressing Enter skips all git operations.
+ */
+/**
+ * Checks if git is available on the system
+ * @returns true if git is installed and available, false otherwise
+ */
+export function isGitAvailable() {
+    try {
+        execSync('git --version', { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Prompts user for optional GitHub repository setup
+ * @returns Repository URL and PAT if user wants git setup, null if skipped
+ */
+export async function promptGitSetup() {
+    // Skip if git is not available
+    if (!isGitAvailable()) {
+        return null;
+    }
+    console.log('');
+    console.log(pc.bold('GitHub Repository (optional)'));
+    console.log(pc.dim('Push your project to a GitHub repository. Press Enter to skip.'));
+    console.log('');
+    // Prompt for repo URL
+    const repoResponse = await prompts({
+        type: 'text',
+        name: 'repoUrl',
+        message: 'GitHub repository URL:',
+    });
+    const repoUrl = repoResponse.repoUrl?.trim();
+    if (!repoUrl) {
+        return null; // User skipped
+    }
+    // Validate the URL
+    try {
+        parseGitHubUrl(repoUrl);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log(pc.red('Error: ') + error.message);
+        }
+        return null;
+    }
+    // Prompt for PAT
+    const patResponse = await prompts({
+        type: 'password',
+        name: 'pat',
+        message: 'GitHub Personal Access Token:',
+        validate: (value) => {
+            if (!value.trim()) {
+                return 'Token is required';
+            }
+            // GitHub tokens start with ghp_ (classic) or github_pat_ (fine-grained)
+            if (!value.startsWith('ghp_') && !value.startsWith('github_pat_')) {
+                return 'Invalid token format. Expected ghp_ or github_pat_ prefix.';
+            }
+            return true;
+        },
+    }, {
+        onCancel: () => {
+            // User cancelled PAT prompt
+            return;
+        },
+    });
+    if (!patResponse.pat) {
+        return null; // User cancelled
+    }
+    return { repoUrl, pat: patResponse.pat };
+}
+/**
+ * Sets up git repository with initial commit and pushes to GitHub
+ * Creates the remote repository if it doesn't exist
+ * @param projectDir - Path to the project directory
+ * @param repoUrl - GitHub repository URL
+ * @param pat - GitHub Personal Access Token
+ */
+export async function setupGitRepository(projectDir, repoUrl, pat) {
+    const spinner = ora();
+    try {
+        // Parse the URL
+        const { owner, repo } = parseGitHubUrl(repoUrl);
+        // Create Octokit client
+        const octokit = createGitHubClient(pat);
+        // Git init
+        spinner.start('Initializing git repository...');
+        execSync('git init -b main', { cwd: projectDir, stdio: 'pipe' });
+        // Check for git user config, set if not configured
+        try {
+            execSync('git config user.name', { cwd: projectDir, stdio: 'pipe' });
+        }
+        catch {
+            // User config not set, use defaults
+            execSync('git config user.name "create-aws-project"', { cwd: projectDir, stdio: 'pipe' });
+            execSync('git config user.email "noreply@create-aws-project"', { cwd: projectDir, stdio: 'pipe' });
+        }
+        execSync('git add .', { cwd: projectDir, stdio: 'pipe' });
+        execSync('git commit -m "Initial commit from create-aws-project"', { cwd: projectDir, stdio: 'pipe' });
+        spinner.succeed('Git repository initialized');
+        // Ensure remote repo exists
+        spinner.start('Checking GitHub repository...');
+        try {
+            await octokit.rest.repos.get({ owner, repo });
+            spinner.succeed(`Repository ${owner}/${repo} found`);
+        }
+        catch (error) {
+            if (error.status === 404) {
+                // Repo doesn't exist, create it
+                const { data: user } = await octokit.rest.users.getAuthenticated();
+                if (owner === user.login) {
+                    // Create in user's account
+                    await octokit.rest.repos.createForAuthenticatedUser({
+                        name: repo,
+                        private: true,
+                        auto_init: false,
+                    });
+                }
+                else {
+                    // Create in organization
+                    await octokit.rest.repos.createInOrg({
+                        org: owner,
+                        name: repo,
+                        private: true,
+                        auto_init: false,
+                    });
+                }
+                spinner.succeed(`Created repository ${owner}/${repo}`);
+            }
+            else {
+                throw error;
+            }
+        }
+        // Push to remote
+        spinner.start('Pushing to GitHub...');
+        const authUrl = `https://${pat}@github.com/${owner}/${repo}.git`;
+        execSync(`git remote add origin ${authUrl}`, { cwd: projectDir, stdio: 'pipe' });
+        execSync('git push -u origin main', { cwd: projectDir, stdio: 'pipe' });
+        // CRITICAL: Remove PAT from .git/config
+        const cleanUrl = `https://github.com/${owner}/${repo}.git`;
+        execSync(`git remote set-url origin ${cleanUrl}`, { cwd: projectDir, stdio: 'pipe' });
+        spinner.succeed(`Pushed to ${owner}/${repo}`);
+    }
+    catch (error) {
+        // Git setup failure should not prevent the user from using their project
+        if (spinner.isSpinning) {
+            spinner.fail();
+        }
+        console.log(pc.yellow('Warning:') + ' Git setup failed: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        console.log(pc.dim('Your project was created successfully. You can set up git manually.'));
+    }
+}

package/dist/wizard.d.ts

@@ -1,2 +1,5 @@
 import type { ProjectConfig } from './types.js';
-export declare function runWizard(): Promise<ProjectConfig | null>;
+export interface WizardOptions {
+    defaultName?: string;
+}
+export declare function runWizard(options?: WizardOptions): Promise<ProjectConfig | null>;

package/dist/wizard.js

@@ -6,9 +6,13 @@ import { authProviderPrompt, authFeaturesPrompt } from './prompts/auth.js';
 import { featuresPrompt } from './prompts/features.js';
 import { awsRegionPrompt } from './prompts/aws-config.js';
 import { themePrompt } from './prompts/theme.js';
-export async function runWizard() {
+export async function runWizard(options = {}) {
+    // Create name prompt with optional default override
+    const namePrompt = options.defaultName
+        ? { ...projectNamePrompt, initial: options.defaultName }
+        : projectNamePrompt;
     const response = await prompts([
-        projectNamePrompt,
+        namePrompt,
         platformsPrompt,
         authProviderPrompt,
         authFeaturesPrompt,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-aws-project",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "description": "CLI tool to scaffold AWS projects",
   "type": "module",
   "main": "./dist/index.js",

package/templates/root/README.md

@@ -109,7 +109,7 @@ Push to main to trigger your first deployment:
 git push origin main
 ```
 
-For detailed setup instructions and troubleshooting, see the [create-aws-project documentation](https://www.npmjs.com/package/create-aws-starter-kit).
+For detailed setup instructions and troubleshooting, see the [create-aws-project documentation](https://www.npmjs.com/package/create-aws-project).
 
 ## CI/CD Workflows