@johnlwin-test/create-repro 0.1.0

package/src/operations.js

@@ -0,0 +1,268 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+/**
+ * Attempts to get available operations for a service by installing and inspecting the package
+ * @param {string} servicePackage - The service package name (e.g., "@aws-sdk/client-s3")
+ * @returns {Promise<{operations: string[], clientName: string, error?: string}>} - Operations in kebab-case, actual client name, and optional error
+ */
+export async function getServiceOperations(servicePackage) {
+	let tempDir = null;
+	try {
+		// Create a temporary directory
+		tempDir = path.join(os.tmpdir(), `aws-sdk-inspect-${Date.now()}`);
+		fs.mkdirSync(tempDir, { recursive: true });
+		
+		// Create a minimal package.json
+		fs.writeFileSync(
+			path.join(tempDir, "package.json"),
+			JSON.stringify({ 
+				name: "temp-inspector",
+				version: "1.0.0",
+				type: "module"
+			})
+		);
+		
+		// Install the package
+		console.log(`  Installing ${servicePackage}...`);
+		try {
+			execSync(`npm install ${servicePackage}@latest --no-save --silent --no-audit --no-fund --loglevel=error`, {
+				cwd: tempDir,
+				stdio: "pipe",
+				timeout: 60000, // 60 second timeout
+			});
+		} catch (installError) {
+			// Check if it's a 404 (package doesn't exist)
+			const errorOutput = installError.stderr?.toString() || installError.message;
+			if (errorOutput.includes('404') || errorOutput.includes('Not Found')) {
+				return { 
+					operations: [], 
+					clientName: "", 
+					error: `Package "${servicePackage}" not found on npm. Please verify the package name.`
+				};
+			}
+			throw installError; // Re-throw other errors
+		}
+		
+		// Find the package directory
+		const packagePath = path.join(tempDir, "node_modules", ...servicePackage.split('/'));
+		
+		if (!fs.existsSync(packagePath)) {
+			throw new Error(`Package not found at ${packagePath}`);
+		}
+		
+		// Read package.json to find exports
+		const packageJsonPath = path.join(packagePath, "package.json");
+		const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+		
+		const operations = new Set();
+		let clientName = "";
+		
+		// Method 1: Parse exports field from package.json
+		if (packageJson.exports) {
+			for (const key of Object.keys(packageJson.exports)) {
+				// Look for command exports like "./commands/ListBucketsCommand"
+				const commandMatch = key.match(/\/commands\/([A-Z][a-zA-Z0-9]+Command)/);
+				if (commandMatch) {
+					const commandName = commandMatch[1];
+					const operationName = commandName
+						.replace(/Command$/, '')
+						.replace(/([A-Z])/g, (match, p1, offset) => 
+							offset > 0 ? `-${p1.toLowerCase()}` : p1.toLowerCase()
+						);
+					operations.add(operationName);
+				}
+				
+				// Look for the client export (e.g., "./DynamoDBClient")
+				const clientMatch = key.match(/^\.\/([A-Za-z0-9]+Client)$/);
+				if (clientMatch && !clientName) {
+					clientName = clientMatch[1];
+				}
+			}
+		}
+		
+		// Method 2: Scan the commands directory if it exists
+		const commandsDir = path.join(packagePath, "dist-cjs", "commands");
+		if (fs.existsSync(commandsDir)) {
+			const files = fs.readdirSync(commandsDir);
+			for (const file of files) {
+				if (file.endsWith('Command.js')) {
+					const commandName = file.replace('.js', '');
+					const operationName = commandName
+						.replace(/Command$/, '')
+						.replace(/([A-Z])/g, (match, p1, offset) => 
+							offset > 0 ? `-${p1.toLowerCase()}` : p1.toLowerCase()
+						);
+					operations.add(operationName);
+				}
+			}
+		}
+		
+		// Method 3: Try dist-es directory
+		const commandsDirES = path.join(packagePath, "dist-es", "commands");
+		if (fs.existsSync(commandsDirES)) {
+			const files = fs.readdirSync(commandsDirES);
+			for (const file of files) {
+				if (file.endsWith('Command.js') || file.endsWith('Command.mjs')) {
+					const commandName = file.replace(/\.(m)?js$/, '');
+					const operationName = commandName
+						.replace(/Command$/, '')
+						.replace(/([A-Z])/g, (match, p1, offset) => 
+							offset > 0 ? `-${p1.toLowerCase()}` : p1.toLowerCase()
+						);
+					operations.add(operationName);
+				}
+			}
+		}
+		
+		// Fallback: Find client name from dist-cjs or dist-es if not found in exports
+		if (!clientName) {
+			for (const distDir of ["dist-cjs", "dist-es"]) {
+				const dir = path.join(packagePath, distDir);
+				if (fs.existsSync(dir)) {
+					const files = fs.readdirSync(dir);
+					const clientFile = files.find(f => f.match(/^[A-Z][a-zA-Z0-9]*Client\.(js|mjs)$/));
+					if (clientFile) {
+						clientName = clientFile.replace(/\.(m)?js$/, '');
+						break;
+					}
+				}
+			}
+		}
+		
+		// Cleanup
+		if (tempDir && fs.existsSync(tempDir)) {
+			fs.rmSync(tempDir, { recursive: true, force: true });
+		}
+		
+		const result = Array.from(operations).sort();
+		console.log(`  Found ${result.length} operations`);
+		if (clientName) {
+			console.log(`  Client: ${clientName}`);
+		}
+		return { operations: result, clientName };
+		
+	} catch (error) {
+		// Cleanup on error
+		if (tempDir && fs.existsSync(tempDir)) {
+			try {
+				fs.rmSync(tempDir, { recursive: true, force: true });
+			} catch (cleanupError) {
+				// Ignore cleanup errors
+			}
+		}
+		
+		// Return error details for better user feedback
+		console.warn(`  Could not fetch operations: ${error.message}`);
+		return { 
+			operations: [], 
+			clientName: "", 
+			error: error.message 
+		};
+	}
+}
+
+/**
+ * Validates operation name format (kebab-case)
+ * @param {string} operation - Operation name to validate
+ * @returns {boolean} - True if valid kebab-case format
+ */
+export function isValidOperationFormat(operation) {
+	// Must be kebab-case: lowercase letters, numbers, and hyphens only
+	// Must start with a letter
+	const kebabCasePattern = /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/;
+	return kebabCasePattern.test(operation);
+}
+
+/**
+ * Validates if an operation exists for a given service
+ * @param {string} operation - Operation name in kebab-case
+ * @param {string[]} availableOperations - List of available operations
+ * @returns {boolean} - True if operation exists
+ */
+export function isValidOperation(operation, availableOperations) {
+	if (availableOperations.length === 0) {
+		// If we don't have the list, just validate format
+		return isValidOperationFormat(operation);
+	}
+	return availableOperations.includes(operation);
+}
+
+/**
+ * Gets operation suggestions based on partial input
+ * @param {string} input - Partial operation name
+ * @param {string[]} availableOperations - List of available operations
+ * @returns {string[]} - Array of matching operation names
+ */
+export function getOperationSuggestions(input, availableOperations) {
+	if (availableOperations.length === 0) return [];
+	
+	const lowerInput = input.toLowerCase();
+	return availableOperations.filter(op => 
+		op.toLowerCase().includes(lowerInput)
+	).slice(0, 20); // Limit to 20 suggestions
+}
+
+/**
+ * Provides helpful error message for invalid operations
+ * @param {string} operation - The invalid operation name
+ * @param {string[]} availableOperations - List of available operations
+ * @returns {string} - Error message with suggestions
+ */
+export function getOperationErrorMessage(operation, availableOperations) {
+	if (!isValidOperationFormat(operation)) {
+		return "Operation must be in kebab-case format (e.g., list-buckets, get-object)";
+	}
+	
+	if (availableOperations.length === 0) {
+		return "Could not validate operation. Please ensure the operation name is correct.";
+	}
+	
+	// Find similar operations (Levenshtein distance or simple substring match)
+	const similar = availableOperations.filter(op => {
+		const distance = levenshteinDistance(operation, op);
+		return distance <= 2; // Allow up to 2 character differences
+	});
+	
+	if (similar.length > 0) {
+		return `Operation not found. Did you mean: ${similar.slice(0, 3).join(", ")}?`;
+	}
+	
+	return `Operation not found. Available operations: ${availableOperations.slice(0, 5).join(", ")}...`;
+}
+
+/**
+ * Calculate Levenshtein distance between two strings
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} - Edit distance
+ */
+function levenshteinDistance(a, b) {
+	const matrix = [];
+	
+	for (let i = 0; i <= b.length; i++) {
+		matrix[i] = [i];
+	}
+	
+	for (let j = 0; j <= a.length; j++) {
+		matrix[0][j] = j;
+	}
+	
+	for (let i = 1; i <= b.length; i++) {
+		for (let j = 1; j <= a.length; j++) {
+			if (b.charAt(i - 1) === a.charAt(j - 1)) {
+				matrix[i][j] = matrix[i - 1][j - 1];
+			} else {
+				matrix[i][j] = Math.min(
+					matrix[i - 1][j - 1] + 1, // substitution
+					matrix[i][j - 1] + 1,     // insertion
+					matrix[i - 1][j] + 1      // deletion
+				);
+			}
+		}
+	}
+	
+	return matrix[b.length][a.length];
+}

package/src/regions.js

@@ -0,0 +1,235 @@
+// Comprehensive list of AWS regions
+
+export const AWS_REGIONS = [
+	// US Regions
+	"us-east-1",      // US East (N. Virginia)
+	"us-east-2",      // US East (Ohio)
+	"us-west-1",      // US West (N. California)
+	"us-west-2",      // US West (Oregon)
+	
+	// Africa
+	"af-south-1",     // Africa (Cape Town)
+	
+	// Asia Pacific
+	"ap-east-1",      // Asia Pacific (Hong Kong)
+	"ap-south-1",     // Asia Pacific (Mumbai)
+	"ap-south-2",     // Asia Pacific (Hyderabad)
+	"ap-northeast-1", // Asia Pacific (Tokyo)
+	"ap-northeast-2", // Asia Pacific (Seoul)
+	"ap-northeast-3", // Asia Pacific (Osaka)
+	"ap-southeast-1", // Asia Pacific (Singapore)
+	"ap-southeast-2", // Asia Pacific (Sydney)
+	"ap-southeast-3", // Asia Pacific (Jakarta)
+	"ap-southeast-4", // Asia Pacific (Melbourne)
+	
+	// Canada
+	"ca-central-1",   // Canada (Central)
+	"ca-west-1",      // Canada (Calgary)
+	
+	// Europe
+	"eu-central-1",   // Europe (Frankfurt)
+	"eu-central-2",   // Europe (Zurich)
+	"eu-west-1",      // Europe (Ireland)
+	"eu-west-2",      // Europe (London)
+	"eu-west-3",      // Europe (Paris)
+	"eu-south-1",     // Europe (Milan)
+	"eu-south-2",     // Europe (Spain)
+	"eu-north-1",     // Europe (Stockholm)
+	
+	// Middle East
+	"me-south-1",     // Middle East (Bahrain)
+	"me-central-1",   // Middle East (UAE)
+	
+	// South America
+	"sa-east-1",      // South America (São Paulo)
+	
+	// AWS GovCloud (US)
+	"us-gov-east-1",  // AWS GovCloud (US-East)
+	"us-gov-west-1",  // AWS GovCloud (US-West)
+	
+	// China (requires separate account)
+	"cn-north-1",     // China (Beijing)
+	"cn-northwest-1", // China (Ningxia)
+];
+
+// Region display names for better UX
+const REGION_NAMES = {
+	"us-east-1": "US East (N. Virginia)",
+	"us-east-2": "US East (Ohio)",
+	"us-west-1": "US West (N. California)",
+	"us-west-2": "US West (Oregon)",
+	"af-south-1": "Africa (Cape Town)",
+	"ap-east-1": "Asia Pacific (Hong Kong)",
+	"ap-south-1": "Asia Pacific (Mumbai)",
+	"ap-south-2": "Asia Pacific (Hyderabad)",
+	"ap-northeast-1": "Asia Pacific (Tokyo)",
+	"ap-northeast-2": "Asia Pacific (Seoul)",
+	"ap-northeast-3": "Asia Pacific (Osaka)",
+	"ap-southeast-1": "Asia Pacific (Singapore)",
+	"ap-southeast-2": "Asia Pacific (Sydney)",
+	"ap-southeast-3": "Asia Pacific (Jakarta)",
+	"ap-southeast-4": "Asia Pacific (Melbourne)",
+	"ca-central-1": "Canada (Central)",
+	"ca-west-1": "Canada (Calgary)",
+	"eu-central-1": "Europe (Frankfurt)",
+	"eu-central-2": "Europe (Zurich)",
+	"eu-west-1": "Europe (Ireland)",
+	"eu-west-2": "Europe (London)",
+	"eu-west-3": "Europe (Paris)",
+	"eu-south-1": "Europe (Milan)",
+	"eu-south-2": "Europe (Spain)",
+	"eu-north-1": "Europe (Stockholm)",
+	"me-south-1": "Middle East (Bahrain)",
+	"me-central-1": "Middle East (UAE)",
+	"sa-east-1": "South America (São Paulo)",
+	"us-gov-east-1": "AWS GovCloud (US-East)",
+	"us-gov-west-1": "AWS GovCloud (US-West)",
+	"cn-north-1": "China (Beijing)",
+	"cn-northwest-1": "China (Ningxia)",
+};
+
+/**
+ * Validates if a region code is valid
+ * @param {string} region - The region code (e.g., "us-west-2")
+ * @returns {boolean} - True if valid, false otherwise
+ */
+export function isValidRegion(region) {
+	return AWS_REGIONS.includes(region.toLowerCase());
+}
+
+/**
+ * Gets the display name for a region
+ * @param {string} region - The region code
+ * @returns {string} - Display name or the region code if not found
+ */
+export function getRegionDisplayName(region) {
+	return REGION_NAMES[region] || region;
+}
+
+/**
+ * Calculate Levenshtein distance between two strings
+ * @param {string} a - First string
+ * @param {string} b - Second string
+ * @returns {number} - Edit distance
+ */
+function levenshteinDistance(a, b) {
+	const matrix = [];
+	
+	for (let i = 0; i <= b.length; i++) {
+		matrix[i] = [i];
+	}
+	
+	for (let j = 0; j <= a.length; j++) {
+		matrix[0][j] = j;
+	}
+	
+	for (let i = 1; i <= b.length; i++) {
+		for (let j = 1; j <= a.length; j++) {
+			if (b.charAt(i - 1) === a.charAt(j - 1)) {
+				matrix[i][j] = matrix[i - 1][j - 1];
+			} else {
+				matrix[i][j] = Math.min(
+					matrix[i - 1][j - 1] + 1, // substitution
+					matrix[i][j - 1] + 1,     // insertion
+					matrix[i - 1][j] + 1      // deletion
+				);
+			}
+		}
+	}
+	
+	return matrix[b.length][a.length];
+}
+
+/**
+ * Finds similar region codes based on typos
+ * @param {string} region - The region code to check
+ * @param {number} maxDistance - Maximum edit distance (default: 2)
+ * @returns {string[]} - Array of similar region codes
+ */
+export function findSimilarRegions(region, maxDistance = 2) {
+	const lowerRegion = region.toLowerCase();
+	
+	return AWS_REGIONS.filter(validRegion => {
+		const distance = levenshteinDistance(lowerRegion, validRegion);
+		return distance > 0 && distance <= maxDistance;
+	}).slice(0, 5); // Limit to top 5 suggestions
+}
+
+/**
+ * Gets region suggestions based on partial input
+ * @param {string} input - Partial region code
+ * @returns {string[]} - Array of matching region codes
+ */
+export function getRegionSuggestions(input) {
+	if (!input) return AWS_REGIONS;
+	
+	const lowerInput = input.toLowerCase();
+	return AWS_REGIONS.filter(region => 
+		region.toLowerCase().includes(lowerInput)
+	);
+}
+
+/**
+ * Validates region format (basic pattern check)
+ * @param {string} region - Region code to validate
+ * @returns {boolean} - True if format is valid
+ */
+export function isValidRegionFormat(region) {
+	// AWS region format: 2-3 letter prefix, direction, number
+	// Examples: us-west-2, ap-southeast-1, eu-central-1
+	const regionPattern = /^[a-z]{2,3}-(north|south|east|west|central|northeast|northwest|southeast|southwest)-\d+$/;
+	const govCloudPattern = /^us-gov-(east|west)-\d+$/;
+	const chinaPattern = /^cn-(north|northwest)-\d+$/;
+	
+	return regionPattern.test(region) || govCloudPattern.test(region) || chinaPattern.test(region);
+}
+
+/**
+ * Provides helpful error message for invalid regions
+ * @param {string} region - The invalid region code
+ * @returns {string} - Error message with suggestions
+ */
+export function getRegionErrorMessage(region) {
+	const lowerRegion = region.toLowerCase();
+	
+	// Check if it's a valid format but not in our list
+	if (!isValidRegionFormat(lowerRegion)) {
+		return `Invalid region format. AWS regions follow the pattern: prefix-direction-number (e.g., us-west-2, eu-central-1)`;
+	}
+	
+	// Find similar regions
+	const similar = findSimilarRegions(lowerRegion);
+	
+	if (similar.length > 0) {
+		const suggestions = similar.map(r => `${r} (${getRegionDisplayName(r)})`).join(", ");
+		return `Region not found. Did you mean: ${suggestions}?`;
+	}
+	
+	// Check for common mistakes
+	if (lowerRegion.includes("_")) {
+		const corrected = lowerRegion.replace(/_/g, "-");
+		if (isValidRegion(corrected)) {
+			return `Invalid format. Did you mean: ${corrected}? (use hyphens, not underscores)`;
+		}
+	}
+	
+	return `Region not found. Use format: prefix-direction-number (e.g., us-west-2, eu-central-1)`;
+}
+
+/**
+ * Converts Java-style region format to standard format
+ * @param {string} region - Region in Java format (e.g., "US_WEST_1")
+ * @returns {string} - Region in standard format (e.g., "us-west-1")
+ */
+export function javaRegionToStandard(region) {
+	return region.toLowerCase().replace(/_/g, "-");
+}
+
+/**
+ * Converts standard region format to Java-style format
+ * @param {string} region - Region in standard format (e.g., "us-west-1")
+ * @returns {string} - Region in Java format (e.g., "US_WEST_1")
+ */
+export function standardRegionToJava(region) {
+	return region.toUpperCase().replace(/-/g, "_");
+}

package/src/sdks/java/generate.js

@@ -0,0 +1,79 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+// import { generateMavenWrapper } from "./utils/maven.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Template cache to avoid repeated file reads
+const TEMPLATES = {
+	mainJava: fs.readFileSync(
+		path.join(__dirname, "templates/Main.java"),
+		"utf-8"
+	),
+	pomXml: fs.readFileSync(path.join(__dirname, "templates/pom.xml"), "utf-8"),
+	readme: fs.readFileSync(path.join(__dirname, "templates/README.md"), "utf-8"),
+};
+
+export const generateJavaProject = (answers, projectDir) => {
+	// Create Maven project structure
+	const paths = {
+		mainJava: path.join(projectDir, "src/main/java/com/aws/repro"),
+		testJava: path.join(projectDir, "src/test/java/com/aws/repro"),
+		resources: path.join(projectDir, "src/main/resources"),
+	};
+
+	// Create directories
+	Object.values(paths).forEach((p) => {
+		fs.mkdirSync(p, { recursive: true });
+	});
+
+	// Process service name for Java SDK
+	const javaService = answers.service.toLowerCase();
+	const operationPascal =
+		answers.operation.charAt(0).toUpperCase() + answers.operation.slice(1);
+
+	// Generate Main.java
+	const mainJavaContent = TEMPLATES.mainJava
+		.replace(/{{service}}/g, javaService)
+		.replace(
+			/{{Service}}/g,
+			javaService.charAt(0).toUpperCase() + javaService.slice(1)
+		)
+		.replace(/{{operation}}/g, answers.operation)
+		.replace(/{{Operation}}/g, operationPascal)
+		.replace(/{{region}}/g, answers.region.toUpperCase());
+
+	// Generate pom.xml
+	const pomXmlContent = TEMPLATES.pomXml
+		.replace(/{{service}}/g, javaService)
+		.replace(/{{aws-sdk-version}}/g, "2.20.136");
+
+	// Generate README
+	const readmeContent = TEMPLATES.readme
+		.replace(/{{service}}/g, javaService)
+		.replace(/{{operation}}/g, answers.operation)
+		.replace(/{{region}}/g, answers.region);
+
+	// Write core files
+	fs.writeFileSync(path.join(paths.mainJava, "Main.java"), mainJavaContent);
+	fs.writeFileSync(path.join(projectDir, "pom.xml"), pomXmlContent);
+	fs.writeFileSync(path.join(projectDir, "README.md"), readmeContent);
+
+	// // Add Maven wrapper
+	// generateMavenWrapper(projectDir);
+
+	// Add .gitignore
+	fs.writeFileSync(
+		path.join(projectDir, ".gitignore"),
+		"target/\n.classpath\n.project\n.settings/\nbin/\n"
+	);
+};
+
+// Helper to render templates with replacements
+function renderTemplate(template, variables) {
+	return Object.entries(variables).reduce(
+		(acc, [key, value]) => acc.replace(new RegExp(`{{${key}}}`, "g"), value),
+		template
+	);
+}

package/src/sdks/java/templates/Main.java

@@ -0,0 +1,24 @@
+package com.aws.repro;
+import software.amazon.awssdk.regions.Region;
+import software.amazon.awssdk.services.{{service}}.{{Service}}Client;
+import software.amazon.awssdk.services.{{service}}.model.{{Operation}}Request;
+import software.amazon.awssdk.services.{{service}}.model.{{Operation}}Response;
+public class Main {
+    public static void main(String[] args) {
+        {{Service}}Client client = {{Service}}Client.builder()
+            .region(Region.{{region}})
+            .build();
+        {{Operation}}Request request = {{Operation}}Request.builder()
+            // Configure request parameters here
+            .build();
+        try {
+            {{Operation}}Response response = client.{{operation}}(request);
+            System.out.println("Operation successful:");
+            System.out.println(response);
+        } catch (Exception e) {
+            System.err.println("Error executing operation:");
+            e.printStackTrace();
+            System.exit(1);
+        }
+    }
+}

package/src/sdks/java/templates/README.md

@@ -0,0 +1,14 @@
+# AWS Java SDK Repro Project
+
+Service: {{service}}  
+Operation: {{operation}}  
+Region: {{region}}
+
+## Running the Project
+
+Configure AWS credentials:
+
+```bash
+export AWS_ACCESS_KEY_ID="YOUR_ACCESS_KEY"
+export AWS_SECRET_ACCESS_KEY="YOUR_SECRET_KEY"
+```

package/src/sdks/java/templates/pom.xml

@@ -0,0 +1,61 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.aws.repro</groupId>
+    <artifactId>aws-java-repro</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+        <aws.sdk.version>2.20.136</aws.sdk.version>
+    </properties>
+
+    <dependencyManagement>
+        <dependencies>
+            <dependency>
+                <groupId>software.amazon.awssdk</groupId>
+                <artifactId>bom</artifactId>
+                <version>${aws.sdk.version}</version>
+                <type>pom</type>
+                <scope>import</scope>
+            </dependency>
+        </dependencies>
+    </dependencyManagement>
+
+    <dependencies>
+        <dependency>
+            <groupId>software.amazon.awssdk</groupId>
+            <artifactId>{{service}}</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.3.0</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>com.aws.repro.Main</mainClass>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>