diff --git a/change/@react-native-windows-cli-add-setup-module-windows-command.json b/change/@react-native-windows-cli-add-setup-module-windows-command.json
new file mode 100644
index 00000000000..f817b3f6222
--- /dev/null
+++ b/change/@react-native-windows-cli-add-setup-module-windows-command.json
@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Add setup-module-windows command with cpp-app template support",
+  "packageName": "@react-native-windows/cli",
+  "email": "copilot@github.com",
+  "dependentChangeType": "patch"
+}
\ No newline at end of file
diff --git a/change/@react-native-windows-telemetry-1c4bdce6-3813-4f87-83c2-a9886bab1b05.json b/change/@react-native-windows-telemetry-1c4bdce6-3813-4f87-83c2-a9886bab1b05.json
new file mode 100644
index 00000000000..b1b821aa6de
--- /dev/null
+++ b/change/@react-native-windows-telemetry-1c4bdce6-3813-4f87-83c2-a9886bab1b05.json
@@ -0,0 +1,7 @@
+{
+  "type": "prerelease",
+  "comment": "Add setup-module-windows command with cpp-app template support",
+  "packageName": "@react-native-windows/telemetry",
+  "email": "54227869+anupriya13@users.noreply.github.com",
+  "dependentChangeType": "patch"
+}
diff --git a/packages/@react-native-windows/cli/src/commands/codegenWindows/codegenWindows.ts b/packages/@react-native-windows/cli/src/commands/codegenWindows/codegenWindows.ts
index b69a709627a..9c472d29e85 100644
--- a/packages/@react-native-windows/cli/src/commands/codegenWindows/codegenWindows.ts
+++ b/packages/@react-native-windows/cli/src/commands/codegenWindows/codegenWindows.ts
@@ -260,58 +260,73 @@ export async function codegenWindowsInternal(
   args: string[],
   config: Config,
   options: CodeGenOptions,
+  existingSpinner?: Ora,
 ) {
   const startTime = performance.now();
-  const spinner = newSpinner(
-    options.check
-      ? 'Checking codegen-windows files...'
-      : 'Running codegen-windows...',
-  );
+  const spinner =
+    existingSpinner ||
+    newSpinner(
+      options.check
+        ? 'Checking codegen-windows files...'
+        : 'Running codegen-windows...',
+    );
+  const shouldLog = !existingSpinner; // Only log completion messages if we created our own spinner
+
   try {
     const codegen = new CodeGenWindows(config.root, options);
     await codegen.run(spinner);
     const endTime = performance.now();
 
     if (!codegen.areChangesNeeded()) {
-      console.log(
-        `${chalk.green(
-          'Success:',
-        )} No codegen-windows changes necessary. (${Math.round(
-          endTime - startTime,
-        )}ms)`,
-      );
+      if (shouldLog) {
+        console.log(
+          `${chalk.green(
+            'Success:',
+          )} No codegen-windows changes necessary. (${Math.round(
+            endTime - startTime,
+          )}ms)`,
+        );
+      }
     } else if (options.check) {
       const codegenCommand = 'npx @react-native-community/cli codegen-windows';
-      console.log(
-        `${chalk.yellow(
-          'Warning:',
-        )} Codegen-windows changes were necessary but ${chalk.bold(
-          '--check',
-        )} specified. Run '${chalk.bold(
-          `${codegenCommand}`,
-        )}' to apply the changes. (${Math.round(endTime - startTime)}ms)`,
-      );
+      if (shouldLog) {
+        console.log(
+          `${chalk.yellow(
+            'Warning:',
+          )} Codegen-windows changes were necessary but ${chalk.bold(
+            '--check',
+          )} specified. Run '${chalk.bold(
+            `${codegenCommand}`,
+          )}' to apply the changes. (${Math.round(endTime - startTime)}ms)`,
+        );
+      }
       throw new CodedError(
         'NeedCodegen',
         `Codegen-windows changes were necessary but --check was specified. Run '${codegenCommand}' to apply the changes`,
       );
     } else {
+      if (shouldLog) {
+        console.log(
+          `${chalk.green(
+            'Success:',
+          )} Codegen-windows changes completed. (${Math.round(
+            endTime - startTime,
+          )}ms)`,
+        );
+      }
+    }
+  } catch (e) {
+    if (!existingSpinner) {
+      spinner.fail();
+    }
+    const endTime = performance.now();
+    if (shouldLog) {
       console.log(
-        `${chalk.green(
-          'Success:',
-        )} Codegen-windows changes completed. (${Math.round(
+        `${chalk.red('Error:')} ${(e as any).toString()}. (${Math.round(
           endTime - startTime,
         )}ms)`,
       );
     }
-  } catch (e) {
-    spinner.fail();
-    const endTime = performance.now();
-    console.log(
-      `${chalk.red('Error:')} ${(e as any).toString()}. (${Math.round(
-        endTime - startTime,
-      )}ms)`,
-    );
     throw e;
   }
 }
diff --git a/packages/@react-native-windows/cli/src/commands/initWindows/initWindows.ts b/packages/@react-native-windows/cli/src/commands/initWindows/initWindows.ts
index 0fbd9d8994a..709abd1ee11 100644
--- a/packages/@react-native-windows/cli/src/commands/initWindows/initWindows.ts
+++ b/packages/@react-native-windows/cli/src/commands/initWindows/initWindows.ts
@@ -372,32 +372,42 @@ async function initWindows(
  * @param args Unprocessed args passed from react-native CLI.
  * @param config Config passed from react-native CLI.
  * @param options Options passed from react-native CLI.
+ * @param existingSpinner Optional existing spinner to use instead of creating a new one.
  */
 export async function initWindowsInternal(
   args: string[],
   config: Config,
   options: InitOptions,
+  existingSpinner?: Ora,
 ) {
   const startTime = performance.now();
-  const spinner = newSpinner('Running init-windows...');
+  const spinner = existingSpinner || newSpinner('Running init-windows...');
+  const shouldLog = !existingSpinner; // Only log completion messages if we created our own spinner
+
   try {
     const codegen = new InitWindows(config, options);
     await codegen.run(spinner);
     const endTime = performance.now();
 
-    console.log(
-      `${chalk.green('Success:')} init-windows completed. (${Math.round(
-        endTime - startTime,
-      )}ms)`,
-    );
+    if (shouldLog) {
+      console.log(
+        `${chalk.green('Success:')} init-windows completed. (${Math.round(
+          endTime - startTime,
+        )}ms)`,
+      );
+    }
   } catch (e) {
-    spinner.fail();
+    if (!existingSpinner) {
+      spinner.fail();
+    }
     const endTime = performance.now();
-    console.log(
-      `${chalk.red('Error:')} ${(e as any).toString()}. (${Math.round(
-        endTime - startTime,
-      )}ms)`,
-    );
+    if (shouldLog) {
+      console.log(
+        `${chalk.red('Error:')} ${(e as any).toString()}. (${Math.round(
+          endTime - startTime,
+        )}ms)`,
+      );
+    }
     throw e;
   }
 }
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/EXAMPLE.md b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/EXAMPLE.md
new file mode 100644
index 00000000000..866f86b9723
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/EXAMPLE.md
@@ -0,0 +1,239 @@
+# Complete Example: Setting up Windows support for react-native-webview
+
+This example demonstrates how to use the `setup-module-windows` command to add Windows support to the popular `react-native-webview` community module.
+
+## Prerequisites
+
+You must have a TurboModule spec file before running the setup command. The command will fail if no spec file exists.
+
+## Step 1: Create TurboModule Spec File
+
+First, create the spec file (`NativeReactNativeWebview.ts`):
+
+```typescript
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import type {TurboModule} from 'react-native/Libraries/TurboModule/RCTExport';
+import {TurboModuleRegistry} from 'react-native';
+
+export interface Spec extends TurboModule {
+  goBack(): void;
+  goForward(): void;
+  reload(): void;
+  stopLoading(): void;
+  loadUrl(url: string): void;
+  evaluateJavaScript(script: string): Promise<string>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNativeWebview');
+```
+
+## Step 2: Run the Setup Command
+
+### For Library Module (default)
+```bash
+cd react-native-webview
+yarn react-native setup-module-windows --logging
+```
+
+### For App Module
+```bash
+cd react-native-webview
+yarn react-native setup-module-windows --template cpp-app --logging
+```
+
+## Step 3: Command Output
+
+```
+✔ Setting up Windows support for React Native module...
+[SetupModuleWindows] Validating environment...
+[SetupModuleWindows] Project name: react-native-webview
+[SetupModuleWindows] Yarn found
+[SetupModuleWindows] Checking for TurboModule spec file...
+[SetupModuleWindows] Found valid spec file(s): NativeReactNativeWebview.ts
+[SetupModuleWindows] Extracted actual module name: ReactNativeWebview
+[SetupModuleWindows] Added codegenConfig to package.json with module name: ReactNativeWebview
+[SetupModuleWindows] Running init-windows with cpp-lib template...
+[SetupModuleWindows] init-windows completed successfully
+[SetupModuleWindows] Running codegen-windows...
+[SetupModuleWindows] codegen-windows completed successfully
+[SetupModuleWindows] Generating C++ stub files...
+[SetupModuleWindows] Generated header stub: /path/to/windows/ReactNativeWebview/ReactNativeWebview.h
+[SetupModuleWindows] Generated cpp stub: /path/to/windows/ReactNativeWebview/ReactNativeWebview.cpp
+
+🎉 Your React Native module now supports Windows!
+
+Files created/updated:
+📄 package.json - Added codegen configuration
+💻 windows/ReactNativeWebview/ReactNativeWebview.h - C++ header file (implement your methods here)
+⚙️  windows/ReactNativeWebview/ReactNativeWebview.cpp - C++ implementation file (add your logic here)
+
+Next steps:
+1. 📝 Update the generated spec file with your module's interface
+2. 🔧 Implement the methods in the generated C++ stub files
+3. 🏗️  Build your project to verify everything works
+4. 📚 See the documentation for more details on TurboModule development
+
+For help, visit: https://microsoft.github.io/react-native-windows/
+```
+
+## Step 4: Final Project Structure
+
+After running the command, your project will have this structure:
+
+### For cpp-lib template (default):
+```
+react-native-webview/
+├── package.json (updated with codegenConfig)
+├── NativeReactNativeWebview.ts (your spec file)
+├── windows/
+│   ├── ReactNativeWebview/
+│   │   ├── ReactNativeWebview.h (generated)
+│   │   └── ReactNativeWebview.cpp (generated)
+│   └── ReactNativeWebview.sln (from init-windows)
+├── codegen/
+│   └── ReactNativeWebviewSpec.g.h (from codegen-windows)
+└── README.md
+```
+
+### For cpp-app template:
+```
+react-native-webview/
+├── package.json (updated with codegenConfig)
+├── NativeReactNativeWebview.ts (your spec file)
+├── windows/
+│   ├── App.xaml
+│   ├── MainWindow.xaml
+│   ├── ReactNativeWebview/
+│   │   ├── ReactNativeWebview.h (generated)
+│   │   └── ReactNativeWebview.cpp (generated)
+│   └── ReactNativeWebview.sln (from init-windows)
+├── codegen/
+│   └── ReactNativeWebviewSpec.g.h (from codegen-windows)
+└── README.md
+```
+
+## Step 5: Generated Files Content
+
+### Header File (ReactNativeWebview.h)
+
+```cpp
+#pragma once
+
+#include "pch.h"
+#include "resource.h"
+
+#include "codegen/NativeReactNativeWebviewSpec.g.h"
+#include "NativeModules.h"
+
+namespace winrt::ReactNativeWebviewSpecs
+{
+
+REACT_MODULE(ReactNativeWebview)
+struct ReactNativeWebview
+{
+  using ModuleSpec = ReactNativeWebviewCodegen::ReactNativeWebviewSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &reactContext) noexcept;
+
+  // Reference function for demonstration (from cpp-lib template)
+  // double multiply(double a, double b) noexcept { return a * b; }
+
+  // Hello World example to verify module functionality
+  REACT_METHOD(sayHello)
+  void sayHello(std::string name, std::function<void(std::string)> const & callback) noexcept;
+
+  // TODO: Add your method implementations here
+
+private:
+  React::ReactContext m_context;
+};
+
+} // namespace winrt::ReactNativeWebviewSpecs
+```
+
+### Implementation File (ReactNativeWebview.cpp)
+
+```cpp
+#include "ReactNativeWebview.h"
+
+namespace winrt::ReactNativeWebviewSpecs {
+
+void ReactNativeWebview::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+}
+
+void ReactNativeWebview::sayHello(std::string name, std::function<void(std::string)> const & callback) noexcept {
+  std::string result = "Hello " + name + "! Module is working.";
+  callback(result);
+}
+
+// TODO: Implement your methods here
+
+} // namespace winrt::ReactNativeWebviewSpecs
+```
+
+## Step 6: Build and Test
+
+```bash
+# Build the Windows project
+cd windows
+msbuild ReactNativeWebview.sln
+
+# Or use Visual Studio to open and build the solution
+```
+
+## Template Differences
+
+### cpp-lib Template (Default)
+- **Use case**: Native modules that provide functionality to React Native apps
+- **Structure**: Library project with module files in subdirectory
+- **Best for**: Community modules, utility libraries, platform bridges
+
+### cpp-app Template
+- **Use case**: Standalone Windows applications with React Native UI
+- **Structure**: Full application project with XAML UI files
+- **Best for**: Complete Windows apps, enterprise applications
+
+## Command Options
+
+### Template Selection
+```bash
+# Use cpp-lib template (default)
+yarn react-native setup-module-windows
+
+# Use cpp-app template
+yarn react-native setup-module-windows --template cpp-app
+
+# Use cpp-lib template explicitly
+yarn react-native setup-module-windows --template cpp-lib
+```
+
+### Other Options
+```bash
+# Verbose logging
+yarn react-native setup-module-windows --logging
+
+# Combine options
+yarn react-native setup-module-windows --template cpp-app --logging
+```
+
+## Error Handling
+
+If you get the error: **"Create Spec File - TurboModule spec file not found"**
+
+This means you need to create a TurboModule spec file first. The command will not automatically create spec files - you must create them manually before running the setup.
+
+## Benefits of Using setup-module-windows
+
+1. **Template Flexibility**: Choose between library and application project structures
+2. **Validation**: Ensures TurboModule spec exists before proceeding
+3. **Best Practices**: Generated files follow RNW coding standards and patterns
+4. **Completeness**: Creates the entire Windows integration structure in one command
+5. **Consistency**: Ensures consistent naming and structure across all Windows modules
+6. **Reference Code**: Includes multiply function reference and working Hello World example
\ No newline at end of file
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/README.md b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/README.md
new file mode 100644
index 00000000000..c6f7971703f
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/README.md
@@ -0,0 +1,173 @@
+# setup-module-windows Command
+
+The `setup-module-windows` command streamlines the process of adding Windows support to React Native community modules. It requires an existing TurboModule spec file and automates the Windows project setup.
+
+## Usage
+
+```bash
+yarn react-native setup-module-windows [options]
+```
+
+## Options
+
+- `--logging`: Enable verbose output logging
+- `--no-telemetry`: Disable telemetry tracking
+- `--template <template>`: Project template (cpp-lib or cpp-app), defaults to cpp-lib
+
+## What it does
+
+The command performs the following steps automatically:
+
+1. **TurboModule Spec Validation**: Checks for existing TurboModule spec files and fails if none are found. You must create a TurboModule spec file before running this command.
+
+2. **Package.json Updates**: Adds or updates the `codegenConfig` section in package.json with proper Windows codegen configuration.
+
+3. **Windows Library Setup**: Runs `init-windows --template <template>` to create the Windows-specific project structure. Supports both `cpp-lib` (default) and `cpp-app` templates.
+
+4. **Code Generation**: Runs `codegen-windows` to generate C++ spec files from TypeScript/JavaScript specs.
+
+5. **C++ Stub Generation**: Creates C++ header (.h) and implementation (.cpp) stub files with:
+   - Proper method signatures matching the TypeScript spec
+   - Reference multiply function as commented example (from cpp-lib template)
+   - Hello World `sayHello` function to verify module functionality
+   - TODO comments for implementing additional methods
+
+## Generated Files
+
+### C++ Header (ModuleName.h)
+Generated with proper module structure:
+
+```cpp
+#pragma once
+
+#include "pch.h"
+#include "resource.h"
+
+#include "codegen/NativeModuleNameSpec.g.h"
+#include "NativeModules.h"
+
+namespace winrt::ModuleNameSpecs
+{
+
+REACT_MODULE(ModuleName)
+struct ModuleName
+{
+  using ModuleSpec = ModuleNameCodegen::ModuleNameSpec;
+
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &reactContext) noexcept;
+
+  // Reference function for demonstration (from cpp-lib template)
+  // double multiply(double a, double b) noexcept { return a * b; }
+
+  // Hello World example to verify module functionality
+  REACT_METHOD(sayHello)
+  void sayHello(std::string name, std::function<void(std::string)> const & callback) noexcept;
+
+  // TODO: Add your method implementations here
+
+private:
+  React::ReactContext m_context;
+};
+
+} // namespace winrt::ModuleNameSpecs
+```
+
+### C++ Implementation (ModuleName.cpp)
+Generated with method stubs including working Hello World example:
+
+```cpp
+#include "ModuleName.h"
+
+namespace winrt::ModuleNameSpecs {
+
+void ModuleName::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+}
+
+void ModuleName::sayHello(std::string name, std::function<void(std::string)> const & callback) noexcept {
+  std::string result = "Hello " + name + "! Module is working.";
+  callback(result);
+}
+
+// TODO: Implement your methods here
+
+} // namespace winrt::ModuleNameSpecs
+```
+
+## Package.json Configuration
+
+The command adds this configuration to your package.json:
+
+```json
+{
+  "codegenConfig": {
+    "name": "ModuleName",
+    "type": "modules",
+    "jsSrcsDir": ".",
+    "windows": {
+      "namespace": "ModuleNameSpecs",
+      "outputDirectory": "codegen",
+      "generators": ["modulesWindows"]
+    }
+  }
+}
+```
+
+## Prerequisites
+
+1. **TurboModule Spec File**: You must create a TurboModule spec file before running this command. The command will fail with an error if no spec file is found.
+
+Example spec file (NativeModuleName.ts):
+```typescript
+import type {TurboModule} from 'react-native/Libraries/TurboModule/RCTExport';
+import {TurboModuleRegistry} from 'react-native';
+
+export interface Spec extends TurboModule {
+  getString(value: string): Promise<string>;
+  getNumber(value: number): Promise<number>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ModuleName');
+```
+
+## Template Options
+
+### cpp-lib (Default)
+- Creates a library project structure
+- Best for native modules that provide functionality to other apps
+- Generates files in `windows/ModuleName/` directory
+
+### cpp-app
+- Creates an application project structure  
+- Best for standalone applications with Windows-specific UI
+- Generates files in `windows/` directory with app structure
+
+## Next Steps
+
+After running the command:
+
+1. **Implement the methods** in the generated C++ stub files - The Hello World function is already implemented as an example
+2. **Build your project** to verify everything works correctly
+3. **Add any additional methods** to your TurboModule spec and C++ implementation
+
+## Examples
+
+Basic usage with default cpp-lib template:
+```bash
+yarn react-native setup-module-windows
+```
+
+With cpp-app template:
+```bash
+yarn react-native setup-module-windows --template cpp-app
+```
+
+With verbose logging:
+```bash
+yarn react-native setup-module-windows --logging
+```
+
+## Error Messages
+
+**"Create Spec File - TurboModule spec file not found"**: You need to create a TurboModule spec file before running this command. The command will not automatically create spec files.
\ No newline at end of file
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/TESTING.md b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/TESTING.md
new file mode 100644
index 00000000000..8a373b80617
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/TESTING.md
@@ -0,0 +1,317 @@
+# Testing the setup-module-windows Command
+
+This guide explains how to test the `setup-module-windows` command locally with both `cpp-lib` and `cpp-app` templates.
+
+## Prerequisites
+
+1. **Build the CLI package locally**:
+   ```bash
+   cd /path/to/react-native-windows
+   yarn install
+   yarn build
+   ```
+
+2. **Ensure you have the required tools**:
+   - Node.js (v20+)
+   - Yarn package manager
+   - Git
+   - Windows SDK (for building C++ components)
+
+## Test Scenarios
+
+### Scenario 1: Test with cpp-lib template (Default)
+
+Create a minimal test module to verify basic functionality:
+
+```bash
+# Create test directory
+mkdir test-react-native-module
+cd test-react-native-module
+
+# Initialize package.json
+npm init -y
+
+# Update package.json with proper React Native module structure
+cat > package.json << 'EOF'
+{
+  "name": "test-react-native-module",
+  "version": "1.0.0",
+  "description": "Test module for setup-module-windows",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/test/test-react-native-module.git"
+  },
+  "keywords": ["react-native"],
+  "author": "Test Author",
+  "license": "MIT",
+  "peerDependencies": {
+    "react-native": "*"
+  }
+}
+EOF
+
+# Create TurboModule spec file (REQUIRED)
+cat > NativeTestModule.ts << 'EOF'
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import type {TurboModule} from 'react-native/Libraries/TurboModule/RCTExport';
+import {TurboModuleRegistry} from 'react-native';
+
+export interface Spec extends TurboModule {
+  getValue(key: string): Promise<string>;
+  setValue(key: string, value: string): Promise<void>;
+  getNumber(defaultValue: number): Promise<number>;
+  getBooleanFlag(): Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('TestModule');
+EOF
+
+# Link to local CLI build
+yarn add file:/absolute/path/to/react-native-windows/packages/@react-native-windows/cli
+
+# Run the setup command with cpp-lib template (default)
+yarn react-native setup-module-windows --logging
+```
+
+**Expected behavior**:
+- Should find the spec file `NativeTestModule.ts`
+- Should create `windows/TestModule/` directory structure
+- Should generate header and cpp files with Hello World example
+- Should include commented multiply function reference
+
+### Scenario 2: Test with cpp-app template
+
+```bash
+# Using the same test module from Scenario 1
+# Run with cpp-app template
+yarn react-native setup-module-windows --template cpp-app --logging
+```
+
+**Expected behavior**:
+- Should find the spec file `NativeTestModule.ts`
+- Should create application project structure in `windows/`
+- Should include XAML files for Windows app
+- Should generate module files in appropriate subdirectory
+
+### Scenario 3: Test error handling - No spec file
+
+```bash
+# Create test directory without spec file
+mkdir test-no-spec-module
+cd test-no-spec-module
+
+# Initialize package.json
+npm init -y
+
+# Link to local CLI build
+yarn add file:/absolute/path/to/react-native-windows/packages/@react-native-windows/cli
+
+# Run the setup command (should fail)
+yarn react-native setup-module-windows --logging
+```
+
+**Expected behavior**:
+- Should fail with error: "Create Spec File - TurboModule spec file not found. Please create a TurboModule spec file before running setup-module-windows."
+- Should not create any Windows files
+- Should exit with non-zero code
+
+### Scenario 4: Test with real community module
+
+Test with a real module like `react-native-webview`:
+
+```bash
+# Clone the repository
+git clone https://github.com/react-native-webview/react-native-webview.git
+cd react-native-webview
+
+# Create a test spec file (since real module may not have one)
+cat > NativeReactNativeWebview.ts << 'EOF'
+import type {TurboModule} from 'react-native/Libraries/TurboModule/RCTExport';
+import {TurboModuleRegistry} from 'react-native';
+
+export interface Spec extends TurboModule {
+  goBack(): void;
+  goForward(): void;
+  reload(): void;
+  postMessage(message: string): void;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('ReactNativeWebview');
+EOF
+
+# Link to your local CLI build
+yarn add file:/absolute/path/to/react-native-windows/packages/@react-native-windows/cli
+
+# Test with cpp-lib template
+yarn react-native setup-module-windows --template cpp-lib --logging
+
+# Clean up and test with cpp-app template
+rm -rf windows codegen
+yarn react-native setup-module-windows --template cpp-app --logging
+```
+
+## Validation Steps
+
+After running the command, verify:
+
+1. **Generated files exist**:
+   ```bash
+   ls -la Native*.ts                    # TypeScript spec file (should exist before)
+   ls -la windows/                      # Windows directory
+   ls -la windows/*/*.h windows/*/*.cpp # C++ implementation files
+   ```
+
+2. **Package.json updated**:
+   ```bash
+   cat package.json | grep -A 10 "codegenConfig"
+   ```
+
+3. **Template-specific files**:
+   
+   For **cpp-lib**:
+   ```bash
+   ls -la windows/ModuleName/           # Module subdirectory
+   ls -la windows/*.sln                 # Solution file
+   ```
+   
+   For **cpp-app**:
+   ```bash
+   ls -la windows/ModuleName/           # Module subdirectory
+   ls -la windows/*.sln                 # Solution file
+   ```
+
+4. **Generated code content**:
+   - Check header file includes Hello World function and commented multiply function
+   - Check cpp file has working Hello World implementation
+   - Verify namespace and class names match spec
+
+5. **Project builds** (optional):
+   ```bash
+   cd windows && msbuild *.sln
+   ```
+
+## Command Line Options Testing
+
+Test different combinations of options:
+
+```bash
+# Basic setup with default template
+yarn react-native setup-module-windows
+
+# With verbose logging
+yarn react-native setup-module-windows --logging
+
+# Different templates
+yarn react-native setup-module-windows --template cpp-lib
+yarn react-native setup-module-windows --template cpp-app
+
+# Skip options
+yarn react-native setup-module-windows --skip-deps
+yarn react-native setup-module-windows --skip-build
+
+# Combined options
+yarn react-native setup-module-windows --template cpp-app --logging --skip-deps
+```
+
+## Expected File Structure
+
+### For cpp-lib template (default):
+```
+test-module/
+├── package.json (updated)
+├── NativeTestModule.ts (spec file)
+├── windows/
+│   ├── TestModule/
+│   │   ├── TestModule.h
+│   │   └── TestModule.cpp
+│   └── TestModule.sln
+└── codegen/
+    └── NativeTestModuleSpec.g.h
+```
+
+### For cpp-app template:
+```
+test-module/
+├── package.json (updated)
+├── NativeTestModule.ts (spec file)
+├── windows/
+│   ├── TestModule/
+│   │   ├── TestModule.h
+│   │   └── TestModule.cpp
+│   └── TestModule.sln
+└── codegen/
+    └── NativeTestModuleSpec.g.h
+```
+
+## Generated Code Verification
+
+### Header File Should Contain:
+```cpp
+// Reference function for demonstration (from cpp-lib template)
+// double multiply(double a, double b) noexcept { return a * b; }
+
+// Hello World example to verify module functionality
+REACT_METHOD(sayHello)
+void sayHello(std::string name, std::function<void(std::string)> const & callback) noexcept;
+```
+
+### Implementation File Should Contain:
+```cpp
+void TestModule::sayHello(std::string name, std::function<void(std::string)> const & callback) noexcept {
+  std::string result = "Hello " + name + "! Module is working.";
+  callback(result);
+}
+```
+
+## Troubleshooting
+
+### Command not found
+If you get "command not found":
+```bash
+# Verify the CLI package is linked
+ls node_modules/@react-native-windows/cli
+
+# Try using npx directly
+npx @react-native-windows/cli setup-module-windows
+```
+
+### Template validation
+Test that invalid templates are rejected:
+```bash
+# Should fail with error
+yarn react-native setup-module-windows --template invalid-template
+```
+
+### Build failures
+If builds fail:
+- Use `--skip-build` to focus on file generation
+- Check Windows SDK installation
+- Verify project structure matches expectations
+
+## Performance Testing
+
+Test with timing to ensure reasonable performance:
+```bash
+time yarn react-native setup-module-windows --logging
+```
+
+Expected completion time should be under 2 minutes for most modules.
+
+## Contributing
+
+When making changes to the command:
+
+1. Test with both template options (`cpp-lib` and `cpp-app`)
+2. Verify error handling with missing spec files
+3. Check generated code follows RNW conventions
+4. Test with multiple real-world modules
+5. Ensure command-line options work correctly
+6. Verify telemetry integration
+
+This comprehensive testing ensures the `setup-module-windows` command works reliably across different module structures and template types.
\ No newline at end of file
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/__tests__/setupModuleWindows.test.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/__tests__/setupModuleWindows.test.ts
new file mode 100644
index 00000000000..a02f81500c4
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/__tests__/setupModuleWindows.test.ts
@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import {SetupModuleWindows} from '../setupModuleWindows';
+import type {SetupModuleWindowsOptions} from '../setupModuleWindowsOptions';
+import fs from '@react-native-windows/fs';
+
+// Mock dependencies
+jest.mock('@react-native-windows/fs');
+jest.mock('glob');
+jest.mock('child_process');
+
+// Type the mocked fs module
+const mockedFs = fs as jest.Mocked<typeof fs>;
+
+describe('SetupModuleWindows', () => {
+  const mockOptions: SetupModuleWindowsOptions = {
+    logging: false,
+    telemetry: false,
+    template: 'cpp-lib',
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getModuleName', () => {
+    it('should convert package names to PascalCase', () => {
+      const setup = new SetupModuleWindows('/test', mockOptions);
+      // Access private method for testing
+      const getModuleName = (setup as any).getModuleName.bind(setup);
+
+      expect(getModuleName('react-native-webview')).toBe('ReactNativeWebview');
+      expect(getModuleName('@react-native-community/slider')).toBe(
+        'ReactNativeCommunitySlider',
+      );
+      expect(getModuleName('simple-module')).toBe('SimpleModule');
+      expect(getModuleName('@scope/complex-package-name')).toBe(
+        'ScopeComplexPackageName',
+      );
+    });
+
+    it('should handle edge cases', () => {
+      const setup = new SetupModuleWindows('/test', mockOptions);
+      const getModuleName = (setup as any).getModuleName.bind(setup);
+
+      expect(getModuleName('')).toBe('');
+      expect(getModuleName('single')).toBe('Single');
+      expect(getModuleName('---multiple---dashes---')).toBe('MultipleDashes');
+    });
+  });
+
+  describe('constructor', () => {
+    it('should create instance with correct root and options', () => {
+      const root = '/test/project';
+      const options = {
+        logging: true,
+        telemetry: true,
+        template: 'cpp-app' as const,
+      };
+
+      const setup = new SetupModuleWindows(root, options);
+
+      expect(setup.root).toBe(root);
+      expect(setup.options).toBe(options);
+    });
+  });
+
+  describe('verboseMessage', () => {
+    it('should log when logging is enabled', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      const setup = new SetupModuleWindows('/test', {logging: true});
+
+      (setup as any).verboseMessage('test message');
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        '[SetupModuleWindows] test message',
+      );
+      consoleSpy.mockRestore();
+    });
+
+    it('should not log when logging is disabled', () => {
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      const setup = new SetupModuleWindows('/test', {logging: false});
+
+      (setup as any).verboseMessage('test message');
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('template option', () => {
+    it('should use cpp-lib as default template', () => {
+      const setup = new SetupModuleWindows('/test', {});
+      expect(setup.options.template).toBeUndefined(); // Will default to cpp-lib in implementation
+    });
+
+    it('should accept cpp-app template', () => {
+      const setup = new SetupModuleWindows('/test', {template: 'cpp-app'});
+      expect(setup.options.template).toBe('cpp-app');
+    });
+
+    it('should accept cpp-lib template', () => {
+      const setup = new SetupModuleWindows('/test', {template: 'cpp-lib'});
+      expect(setup.options.template).toBe('cpp-lib');
+    });
+  });
+
+  describe('spec file validation', () => {
+    beforeEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('should throw error if no spec file exists', async () => {
+      const glob = require('glob');
+      glob.sync.mockReturnValue([]);
+
+      const setup = new SetupModuleWindows('/test', {logging: true});
+
+      await expect((setup as any).checkForExistingSpec()).rejects.toThrow(
+        'Create Spec File - TurboModule spec file not found. Please create a TurboModule spec file before running setup-module-windows.',
+      );
+    });
+
+    it('should accept valid TurboModule spec files', async () => {
+      const glob = require('glob');
+      glob.sync.mockReturnValue(['NativeTestModule.ts']);
+
+      mockedFs.exists.mockResolvedValue(true);
+      mockedFs.readFile.mockResolvedValue(`
+        import type {TurboModule} from 'react-native/Libraries/TurboModule/RCTExport';
+        import {TurboModuleRegistry} from 'react-native';
+
+        export interface Spec extends TurboModule {
+          getString(): Promise<string>;
+        }
+
+        export default TurboModuleRegistry.getEnforcing<Spec>('TestModule');
+      `);
+
+      const setup = new SetupModuleWindows('/test', {logging: true});
+
+      await expect(
+        (setup as any).checkForExistingSpec(),
+      ).resolves.toBeUndefined();
+    });
+  });
+});
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/index.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/index.ts
new file mode 100644
index 00000000000..aefd0ed8626
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/index.ts
@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+export {
+  setupModuleWindowsCommand,
+  setupModuleWindowsInternal,
+} from './setupModuleWindows';
+export type {SetupModuleWindowsOptions} from './setupModuleWindowsOptions';
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/setupModuleWindows.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/setupModuleWindows.ts
new file mode 100644
index 00000000000..2b8caa8f045
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/setupModuleWindows.ts
@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import chalk from 'chalk';
+import {Ora} from 'ora';
+
+import type {Command, Config} from '@react-native-community/cli-types';
+import {Telemetry} from '@react-native-windows/telemetry';
+
+import {
+  newSpinner,
+  setExitProcessWithError,
+} from '../../utils/commandWithProgress';
+import {
+  getDefaultOptions,
+  startTelemetrySession,
+  endTelemetrySession,
+} from '../../utils/telemetryHelpers';
+import type {SetupModuleWindowsOptions} from './setupModuleWindowsOptions';
+import {setupModuleWindowsOptions} from './setupModuleWindowsOptions';
+import {
+  validateEnvironment,
+  checkForExistingSpec,
+} from './utils/validationUtils';
+import {
+  getFinalModuleName,
+  updatePackageJsonCodegen,
+} from './utils/moduleNameUtils';
+import {
+  runInitWindows,
+  runCodegenWindows,
+  getActualProjectPaths,
+} from './utils/projectSetupUtils';
+import {generateStubFiles} from './utils/templateGenerationUtils';
+
+/**
+ * Sanitizes the given option for telemetry.
+ * @param key The key of the option.
+ * @param value The unsanitized value of the option.
+ * @returns The sanitized value of the option.
+ */
+function optionSanitizer(
+  key: keyof SetupModuleWindowsOptions,
+  value: any,
+): any {
+  // Do not add a default case here.
+  // Strings risking PII should just return true if present, false otherwise.
+  // All others should return the value (or false if undefined).
+  switch (key) {
+    case 'logging':
+    case 'telemetry':
+    case 'template':
+      return value === undefined ? false : value; // Return value
+  }
+}
+
+/**
+ * Get the extra props to add to the `setup-module-windows` telemetry event.
+ * @returns The extra props.
+ */
+async function getExtraProps(): Promise<Record<string, any>> {
+  const extraProps: Record<string, any> = {};
+  return extraProps;
+}
+
+export class SetupModuleWindows {
+  private actualModuleName?: string;
+  private actualProjectPath?: string;
+  public root: string;
+  public options: SetupModuleWindowsOptions;
+
+  constructor(root: string, options: SetupModuleWindowsOptions) {
+    this.root = root;
+    this.options = options;
+  }
+
+  public getActualProjectPaths(): {headerPath: string; cppPath: string} {
+    // Use the actual project path if available, otherwise fall back to calculated path
+    if (this.actualProjectPath) {
+      return {
+        headerPath: `${this.actualProjectPath}.h`,
+        cppPath: `${this.actualProjectPath}.cpp`,
+      };
+    }
+    return getActualProjectPaths(this.root, this.actualModuleName);
+  }
+
+  public async run(spinner: Ora, config: Config): Promise<void> {
+    await validateEnvironment(this.root, this.options.logging ?? false);
+    spinner.text = 'Checking for TurboModule spec file...';
+
+    const {actualModuleName} = await checkForExistingSpec(
+      this.root,
+      this.options.logging ?? false,
+    );
+    this.actualModuleName = actualModuleName;
+
+    // Now begin the Windows setup process
+    spinner.text = 'Updating package.json with codegen configuration...';
+    await updatePackageJsonCodegen(this.root, this.options.logging ?? false);
+
+    spinner.text = 'Running init-windows...';
+    await runInitWindows(this.root, config, this.options, spinner);
+
+    spinner.text = 'Running codegen-windows...';
+    await runCodegenWindows(this.root, config, this.options, spinner);
+
+    spinner.text = 'Generating C++ stub files...';
+    const {actualProjectPath} = await generateStubFiles(
+      this.root,
+      this.actualModuleName,
+      this.options.logging ?? false,
+    );
+    this.actualProjectPath = actualProjectPath;
+
+    spinner.succeed();
+
+    // Print success message with helpful information
+    const paths = this.getActualProjectPaths();
+
+    // Get the actual module name from the project path
+    const moduleName = await getFinalModuleName(
+      this.root,
+      this.actualModuleName,
+    );
+    let displayModuleName = moduleName;
+    if (this.actualProjectPath) {
+      // Extract the module name from the actual project path
+      const pathParts = this.actualProjectPath.split(/[/\\]/);
+      displayModuleName = pathParts[pathParts.length - 1]; // Get the last part (file name without extension)
+    }
+
+    console.log(
+      `\n${chalk.green('Success!')} Windows module setup completed.\n`,
+    );
+
+    console.log(`${chalk.bold('Module Name:')} ${displayModuleName}`);
+    console.log(`${chalk.bold('Generated Files:')}`);
+    console.log(`  • ${paths.headerPath}`);
+    console.log(`  • ${paths.cppPath}`);
+    console.log(`  • codegen/Native${displayModuleName}Spec.g.h`);
+
+    console.log(`\n${chalk.bold('Next Steps:')}`);
+    console.log('1. Implement your module methods in the generated C++ files');
+    console.log('2. Add your module to the React Native Windows project');
+    console.log(
+      '3. Build and test your module using the provided Hello World example',
+    );
+
+    console.log(
+      `\n${chalk.blue(
+        'Learn More:',
+      )} https://microsoft.github.io/react-native-windows/docs/native-platform`,
+    );
+  }
+}
+
+/**
+ * Function to setup Windows support for React Native community modules.
+ */
+export async function setupModuleWindows(
+  args: string[],
+  config: Config,
+  options: SetupModuleWindowsOptions,
+) {
+  await startTelemetrySession(
+    'setup-module-windows',
+    config,
+    options,
+    getDefaultOptions(config, setupModuleWindowsOptions),
+    optionSanitizer,
+  );
+
+  let setupModuleWindowsError: Error | undefined;
+  try {
+    await setupModuleWindowsInternal(args, config, options);
+  } catch (ex) {
+    setupModuleWindowsError =
+      ex instanceof Error ? (ex as Error) : new Error(String(ex));
+    Telemetry.trackException(setupModuleWindowsError);
+  }
+
+  await endTelemetrySession(setupModuleWindowsError, getExtraProps);
+  setExitProcessWithError(options.logging, setupModuleWindowsError);
+}
+
+/**
+ * Internal function for use by other commands
+ */
+export async function setupModuleWindowsInternal(
+  args: string[],
+  config: Config,
+  options: SetupModuleWindowsOptions,
+): Promise<void> {
+  // Suppress Node.js deprecation warnings during this command
+  const originalNoWarnings = process.env.NODE_NO_WARNINGS;
+  process.env.NODE_NO_WARNINGS = '1';
+
+  try {
+    const spinner = newSpinner('Setting up Windows module...');
+
+    const setupModule = new SetupModuleWindows(config.root, {
+      ...getDefaultOptions(config, setupModuleWindowsOptions),
+      ...options,
+    });
+
+    await setupModule.run(spinner, config);
+  } finally {
+    // Restore original NODE_NO_WARNINGS setting
+    if (originalNoWarnings !== undefined) {
+      process.env.NODE_NO_WARNINGS = originalNoWarnings;
+    } else {
+      delete process.env.NODE_NO_WARNINGS;
+    }
+  }
+}
+
+/**
+ * Sets up Windows support for React Native community modules.
+ */
+export const setupModuleWindowsCommand: Command = {
+  name: 'setup-module-windows',
+  description:
+    'Streamlined setup of Windows support for React Native community modules',
+  func: setupModuleWindows,
+  options: setupModuleWindowsOptions,
+};
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/setupModuleWindowsOptions.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/setupModuleWindowsOptions.ts
new file mode 100644
index 00000000000..fc9b92a1a73
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/setupModuleWindowsOptions.ts
@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import type {CommandOption} from '@react-native-community/cli-types';
+
+export interface SetupModuleWindowsOptions {
+  logging?: boolean;
+  telemetry?: boolean;
+  template?: 'cpp-lib' | 'cpp-app';
+}
+
+export const setupModuleWindowsOptions: CommandOption[] = [
+  {
+    name: '--logging',
+    description: 'Verbose output logging',
+  },
+  {
+    name: '--no-telemetry',
+    description:
+      'Disables sending telemetry that allows analysis of usage and failures of the react-native-windows CLI',
+  },
+  {
+    name: '--template [string]',
+    description: 'Project template (cpp-lib or cpp-app)',
+    default: 'cpp-lib',
+  },
+];
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/moduleNameUtils.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/moduleNameUtils.ts
new file mode 100644
index 00000000000..7a482822eb3
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/moduleNameUtils.ts
@@ -0,0 +1,88 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import path from 'path';
+import fs from '@react-native-windows/fs';
+
+export function getModuleName(packageName: string): string {
+  // Convert package name to PascalCase module name
+  // e.g., "react-native-webview" -> "ReactNativeWebview"
+  // e.g., "@react-native-community/slider" -> "ReactNativeCommunitySlider"
+  return packageName
+    .replace(/[@/-]/g, ' ')
+    .split(' ')
+    .filter(word => word.length > 0)
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+    .join('');
+}
+
+export function getActualModuleName(packageName: string): string {
+  // Similar to getModuleName but handles scoped packages differently
+  // e.g., "@company/react-native-module" -> "CompanyReactNativeModule"
+  if (packageName.startsWith('@')) {
+    return packageName
+      .replace('@', '')
+      .replace(/[/-]/g, ' ')
+      .split(' ')
+      .filter(word => word.length > 0)
+      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+      .join('');
+  }
+  return getModuleName(packageName);
+}
+
+export async function getFinalModuleName(
+  root: string,
+  actualModuleName?: string,
+): Promise<string> {
+  if (actualModuleName) {
+    return actualModuleName;
+  }
+
+  const packageJsonPath = path.join(root, 'package.json');
+  const pkgJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+  return getActualModuleName(pkgJson.name || 'SampleModule');
+}
+
+export async function updatePackageJsonCodegen(
+  root: string,
+  logging: boolean,
+): Promise<void> {
+  if (logging) {
+    console.log(
+      '[SetupModuleWindows] Checking and updating package.json codegen configuration...',
+    );
+  }
+
+  const packageJsonPath = path.join(root, 'package.json');
+  const pkgJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+
+  if (!pkgJson.codegenConfig) {
+    const moduleName = getActualModuleName(pkgJson.name || 'SampleModule');
+
+    pkgJson.codegenConfig = {
+      name: moduleName,
+      type: 'modules',
+      jsSrcsDir: '.',
+      windows: {
+        namespace: `${moduleName}Specs`,
+        outputDirectory: 'codegen',
+        generators: ['modulesWindows'],
+      },
+    };
+
+    await fs.writeFile(packageJsonPath, JSON.stringify(pkgJson, null, 2));
+    if (logging) {
+      console.log('[SetupModuleWindows] Added codegenConfig to package.json');
+    }
+  } else {
+    if (logging) {
+      console.log(
+        '[SetupModuleWindows] codegenConfig already exists in package.json',
+      );
+    }
+  }
+}
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/projectSetupUtils.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/projectSetupUtils.ts
new file mode 100644
index 00000000000..78808b78788
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/projectSetupUtils.ts
@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import type {Config} from '@react-native-community/cli-types';
+import fs from '@react-native-windows/fs';
+import path from 'path';
+import {Ora} from 'ora';
+
+import {initWindowsInternal} from '../../initWindows/initWindows';
+import {codegenWindowsInternal} from '../../codegenWindows/codegenWindows';
+import type {SetupModuleWindowsOptions} from '../setupModuleWindowsOptions';
+import {getActualModuleName} from './moduleNameUtils';
+
+export async function runInitWindows(
+  root: string,
+  config: Config,
+  options: SetupModuleWindowsOptions,
+  spinner: Ora,
+): Promise<void> {
+  // Handle problematic example directory for cpp-lib template
+  const exampleDir = path.join(root, 'example');
+  const examplePackageJson = path.join(exampleDir, 'package.json');
+  let temporarilyRenamed = false;
+  let tempExampleDir = '';
+
+  try {
+    // If using cpp-lib template and example directory exists but doesn't have a proper package.json,
+    // temporarily rename it to avoid template processing issues
+    if (
+      (options.template || 'cpp-lib') === 'cpp-lib' &&
+      (await fs.exists(exampleDir)) &&
+      !(await fs.exists(examplePackageJson))
+    ) {
+      tempExampleDir = path.join(root, 'example.temp.setup-module-windows');
+      await fs.rename(exampleDir, tempExampleDir);
+      temporarilyRenamed = true;
+      if (options.logging) {
+        console.log(
+          '[SetupModuleWindows] Temporarily renamed example directory to avoid conflicts',
+        );
+      }
+    }
+
+    const modifiedConfig: Config = {
+      ...config,
+      root: root,
+    };
+
+    await initWindowsInternal(
+      [],
+      modifiedConfig,
+      {
+        template: options.template || 'cpp-lib',
+        logging: false, // Disable internal logging to avoid conflicts with spinner
+        telemetry: options.telemetry,
+        overwrite: true,
+        namespace: '',
+      },
+      spinner,
+    );
+
+    if (options.logging) {
+      console.log('[SetupModuleWindows] init-windows completed successfully');
+    }
+  } catch (error: any) {
+    if (options.logging) {
+      console.log('[SetupModuleWindows] init-windows failed:', error.message);
+    }
+    throw error;
+  } finally {
+    // Restore the temporarily renamed example directory
+    if (temporarilyRenamed && tempExampleDir) {
+      try {
+        if (await fs.exists(tempExampleDir)) {
+          await fs.rename(tempExampleDir, exampleDir);
+          if (options.logging) {
+            console.log('[SetupModuleWindows] Restored example directory');
+          }
+        }
+      } catch (restoreError: any) {
+        if (options.logging) {
+          console.log(
+            '[SetupModuleWindows] Warning: Failed to restore example directory:',
+            restoreError.message,
+          );
+        }
+      }
+    }
+  }
+}
+
+export async function runCodegenWindows(
+  root: string,
+  config: Config,
+  options: SetupModuleWindowsOptions,
+  spinner: Ora,
+): Promise<void> {
+  try {
+    const modifiedConfig: Config = {
+      ...config,
+      root: root,
+    };
+
+    await codegenWindowsInternal(
+      [],
+      modifiedConfig,
+      {
+        logging: false, // Disable internal logging to avoid conflicts with spinner
+        telemetry: options.telemetry,
+      },
+      spinner,
+    );
+
+    if (options.logging) {
+      console.log(
+        '[SetupModuleWindows] codegen-windows completed successfully',
+      );
+    }
+  } catch (error: any) {
+    // Check if codegen directory was created even with errors
+    const codegenDir = path.join(root, 'codegen');
+    if (await fs.exists(codegenDir)) {
+      if (options.logging) {
+        console.log(
+          '[SetupModuleWindows] codegen-windows completed with warnings, but codegen directory was created',
+        );
+      }
+      return; // Continue execution
+    }
+    if (options.logging) {
+      console.log(
+        '[SetupModuleWindows] codegen-windows failed:',
+        error.message,
+      );
+    }
+    throw error;
+  }
+}
+
+export function getActualProjectPaths(
+  root: string,
+  actualModuleName?: string,
+): {headerPath: string; cppPath: string} {
+  // If we have an actual module name, use it
+  if (actualModuleName) {
+    return {
+      headerPath: `windows/${actualModuleName}/${actualModuleName}.h`,
+      cppPath: `windows/${actualModuleName}/${actualModuleName}.cpp`,
+    };
+  }
+
+  // Otherwise, derive from package name
+  const packageJsonPath = path.join(root, 'package.json');
+  const pkgJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  const moduleName = getActualModuleName(pkgJson.name || 'SampleModule');
+
+  return {
+    headerPath: `windows/${moduleName}/${moduleName}.h`,
+    cppPath: `windows/${moduleName}/${moduleName}.cpp`,
+  };
+}
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/templateGenerationUtils.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/templateGenerationUtils.ts
new file mode 100644
index 00000000000..5fae2d02397
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/templateGenerationUtils.ts
@@ -0,0 +1,712 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import path from 'path';
+import fs from '@react-native-windows/fs';
+import {getFinalModuleName} from './moduleNameUtils';
+
+interface MethodSignature {
+  name: string;
+  returnType: string;
+  parameters: {name: string; type: string; fullType?: string}[];
+}
+
+export async function generateStubFiles(
+  root: string,
+  actualModuleName?: string,
+  logging?: boolean,
+): Promise<{actualProjectPath?: string}> {
+  if (logging) {
+    console.log('[SetupModuleWindows] Generating C++ stub files...');
+  }
+
+  // First, find the actual Windows project directory that was created by init-windows
+  const windowsDir = path.join(root, 'windows');
+  let actualProjectName = '';
+
+  try {
+    const windowsDirContents = await fs.readdir(windowsDir);
+    const projectDirs = [];
+
+    for (const item of windowsDirContents) {
+      const itemPath = path.join(windowsDir, item);
+      const stats = await fs.stat(itemPath);
+
+      if (
+        stats.isDirectory() &&
+        !item.startsWith('.') &&
+        item !== 'ExperimentalFeatures.props' &&
+        !item.endsWith('.sln')
+      ) {
+        // Check if this directory contains typical project files
+        const possibleHeaderFile = path.join(itemPath, `${item}.h`);
+        const possibleCppFile = path.join(itemPath, `${item}.cpp`);
+        if (
+          (await fs.exists(possibleHeaderFile)) ||
+          (await fs.exists(possibleCppFile))
+        ) {
+          projectDirs.push(item);
+        }
+      }
+    }
+
+    if (projectDirs.length > 0) {
+      actualProjectName = projectDirs[0];
+      if (logging) {
+        console.log(
+          `[SetupModuleWindows] Found Windows project directory: ${actualProjectName}`,
+        );
+      }
+    }
+  } catch (error) {
+    if (logging) {
+      console.log(
+        `[SetupModuleWindows] Error searching for Windows project directory: ${error}`,
+      );
+    }
+  }
+
+  // Look for codegen directory - try multiple possible locations
+  let codegenDir = path.join(root, 'codegen');
+  let foundCodegen = false;
+
+  // Check root level first
+  if (await fs.exists(codegenDir)) {
+    foundCodegen = true;
+    if (logging) {
+      console.log(
+        `[SetupModuleWindows] Found codegen directory at: ${codegenDir}`,
+      );
+    }
+  }
+  // Check inside Windows project directory
+  else if (actualProjectName) {
+    const projectCodegenDir = path.join(
+      windowsDir,
+      actualProjectName,
+      'codegen',
+    );
+    if (await fs.exists(projectCodegenDir)) {
+      codegenDir = projectCodegenDir;
+      foundCodegen = true;
+      if (logging) {
+        console.log(
+          `[SetupModuleWindows] Found codegen directory at: ${codegenDir}`,
+        );
+      }
+    }
+    // Also check with different casing (Codegen vs codegen)
+    else {
+      const projectCodegenDirAlt = path.join(
+        windowsDir,
+        actualProjectName,
+        'Codegen',
+      );
+      if (await fs.exists(projectCodegenDirAlt)) {
+        codegenDir = projectCodegenDirAlt;
+        foundCodegen = true;
+        if (logging) {
+          console.log(
+            `[SetupModuleWindows] Found codegen directory at: ${codegenDir}`,
+          );
+        }
+      }
+    }
+  }
+
+  if (!foundCodegen) {
+    if (logging) {
+      console.log(
+        '[SetupModuleWindows] No codegen directory found, skipping stub generation',
+      );
+    }
+    return {};
+  }
+
+  const files = await fs.readdir(codegenDir);
+  const specFiles = files.filter(file => file.endsWith('Spec.g.h'));
+
+  if (specFiles.length === 0) {
+    if (logging) {
+      console.log(
+        '[SetupModuleWindows] No Spec.g.h files found in codegen directory',
+      );
+    }
+    return {};
+  }
+
+  if (logging) {
+    console.log(
+      `[SetupModuleWindows] Found ${
+        specFiles.length
+      } codegen spec file(s): ${specFiles.join(', ')}`,
+    );
+  }
+
+  // Use the actual project name we found, or fall back to calculated module name
+  let projectName = actualProjectName;
+  let actualProjectPath: string | undefined;
+  let moduleDir: string;
+
+  if (projectName) {
+    // Use the actual project directory that was found
+    moduleDir = path.join(windowsDir, projectName);
+    actualProjectPath = path.join('windows', projectName, projectName);
+    if (logging) {
+      console.log(
+        `[SetupModuleWindows] Using existing Windows project directory: ${moduleDir}`,
+      );
+    }
+  } else {
+    // Fall back to calculated module name if no project directory was found
+    const moduleName = await getFinalModuleName(root, actualModuleName);
+    projectName = moduleName;
+    moduleDir = path.join(windowsDir, moduleName);
+    actualProjectPath = path.join('windows', moduleName, moduleName);
+
+    if (!(await fs.exists(moduleDir))) {
+      await fs.mkdir(moduleDir, {recursive: true});
+    }
+  }
+
+  // Parse methods from codegen files
+  const methods = await parseMethodsFromCodegen(codegenDir, specFiles, logging);
+
+  // Generate header and cpp files
+  const headerPath = path.join(moduleDir, `${projectName}.h`);
+  const cppPath = path.join(moduleDir, `${projectName}.cpp`);
+
+  const headerContent = await generateHeaderStub(projectName, methods);
+  await fs.writeFile(headerPath, headerContent);
+  if (logging) {
+    console.log(
+      `[SetupModuleWindows] Generated header stub: ${headerPath} with ${methods.length} methods`,
+    );
+  }
+
+  const cppContent = await generateCppStub(projectName, methods);
+  await fs.writeFile(cppPath, cppContent);
+  if (logging) {
+    console.log(
+      `[SetupModuleWindows] Generated cpp stub: ${cppPath} with ${methods.length} methods`,
+    );
+  }
+
+  return {actualProjectPath};
+}
+
+async function parseMethodsFromCodegen(
+  codegenDir: string,
+  specFiles: string[],
+  logging?: boolean,
+): Promise<MethodSignature[]> {
+  const methods: MethodSignature[] = [];
+
+  for (const specFile of specFiles) {
+    const specPath = path.join(codegenDir, specFile);
+    try {
+      const content = await fs.readFile(specPath, 'utf8');
+      const fileMethods = extractMethodsFromCodegenHeader(content, logging);
+      methods.push(...fileMethods);
+
+      if (logging) {
+        console.log(
+          `[SetupModuleWindows] Extracted ${
+            fileMethods.length
+          } methods from ${specFile}: ${fileMethods
+            .map(m => m.name)
+            .join(', ')}`,
+        );
+      }
+    } catch (error) {
+      if (logging) {
+        console.log(`[SetupModuleWindows] Error parsing ${specFile}: ${error}`);
+      }
+    }
+  }
+
+  return methods;
+}
+
+function extractMethodsFromCodegenHeader(
+  content: string,
+  logging?: boolean,
+): MethodSignature[] {
+  const methods: MethodSignature[] = [];
+
+  // Parse from REACT_SHOW_METHOD_SPEC_ERRORS sections which contain the exact method signatures
+  // Use a more sophisticated pattern to handle nested parentheses and function callbacks
+  const errorSectionPattern =
+    /REACT_SHOW_METHOD_SPEC_ERRORS\s*\(\s*\d+,\s*"([^"]+)",\s*"([^"]*)"/g;
+
+  let match;
+  while ((match = errorSectionPattern.exec(content)) !== null) {
+    const methodName = match[1]; // Method name from first parameter
+    const fullMethodSignature = match[2]; // Full method signature string
+
+    // Extract parameters from the full method signature
+    const methodMatch = fullMethodSignature.match(
+      /REACT_METHOD\([^)]+\)\s+(?:static\s+)?void\s+\w+\s*\(([^]*)\)/,
+    );
+    if (methodMatch) {
+      // Need to carefully parse the parameters, handling nested parentheses
+      const parametersString = methodMatch[1];
+      const parameters = parseComplexParameters(parametersString);
+
+      methods.push({
+        name: methodName,
+        returnType: 'void', // Codegen methods are typically void with callbacks or promises
+        parameters: parameters,
+      });
+
+      if (logging) {
+        console.log(
+          `[SetupModuleWindows] Parsed method ${methodName} with parameters: ${parametersString}`,
+        );
+      }
+    }
+  }
+
+  // Also try to parse from the methods tuple for additional methods
+  if (methods.length === 0) {
+    const methodsTuplePattern = /Method<([^>]+)>\{\s*(\d+),\s*L"([^"]+)"\s*\}/g;
+
+    while ((match = methodsTuplePattern.exec(content)) !== null) {
+      const signature = match[1]; // Method signature type
+      const methodName = match[3]; // Method name
+      const parameters = parseCodegenSignature(signature);
+
+      methods.push({
+        name: methodName,
+        returnType: 'void',
+        parameters: parameters,
+      });
+    }
+  }
+
+  // Try parsing directly from C++ method declarations in the header
+  if (methods.length === 0) {
+    if (logging) {
+      console.log(
+        '[SetupModuleWindows] Trying to parse C++ method declarations directly...',
+      );
+    }
+
+    // Look for virtual method declarations like:
+    // virtual void MethodName(parameters) = 0;
+    const virtualMethodPattern =
+      /virtual\s+(\w+(?:\s*\*)?)\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?=\s*0\s*;/g;
+
+    while ((match = virtualMethodPattern.exec(content)) !== null) {
+      const returnType = match[1].trim();
+      const methodName = match[2];
+      const paramString = match[3];
+      const parameters = parseCodegenParameters(paramString);
+
+      methods.push({
+        name: methodName,
+        returnType: returnType === 'void' ? 'void' : returnType,
+        parameters: parameters,
+      });
+    }
+  }
+
+  if (logging && methods.length > 0) {
+    console.log(
+      `[SetupModuleWindows] Extracted ${methods.length} methods from codegen header using multiple parsing strategies`,
+    );
+  }
+
+  return methods;
+}
+
+function parseComplexParameters(
+  paramString: string,
+): {name: string; type: string; fullType?: string}[] {
+  if (!paramString || paramString.trim() === '') {
+    return [];
+  }
+
+  const params: {name: string; type: string; fullType?: string}[] = [];
+
+  // Handle complex parameter parsing with nested parentheses
+  let current = '';
+  let depth = 0;
+  let inString = false;
+  let i = 0;
+
+  while (i < paramString.length) {
+    const char = paramString[i];
+
+    if (char === '"' && (i === 0 || paramString[i - 1] !== '\\')) {
+      inString = !inString;
+    } else if (!inString) {
+      if (char === '<' || char === '(') {
+        depth++;
+      } else if (char === '>' || char === ')') {
+        depth--;
+      } else if (char === ',' && depth === 0) {
+        if (current.trim()) {
+          params.push(parseCodegenParameter(current.trim()));
+        }
+        current = '';
+        i++;
+        continue;
+      }
+    }
+
+    current += char;
+    i++;
+  }
+
+  if (current.trim()) {
+    params.push(parseCodegenParameter(current.trim()));
+  }
+
+  return params;
+}
+
+function parseCodegenParameters(
+  paramString: string,
+): {name: string; type: string; fullType?: string}[] {
+  if (!paramString || paramString.trim() === '') {
+    return [];
+  }
+
+  const params: {name: string; type: string; fullType?: string}[] = [];
+
+  // Split parameters carefully, handling nested templates like std::function<void(bool)>
+  const cleanParamString = paramString.trim();
+  let current = '';
+  let depth = 0;
+  let inString = false;
+
+  for (let i = 0; i < cleanParamString.length; i++) {
+    const char = cleanParamString[i];
+
+    if (char === '"' && cleanParamString[i - 1] !== '\\') {
+      inString = !inString;
+    } else if (!inString) {
+      if (char === '<' || char === '(') {
+        depth++;
+      } else if (char === '>' || char === ')') {
+        depth--;
+      } else if (char === ',' && depth === 0) {
+        if (current.trim()) {
+          params.push(parseCodegenParameter(current.trim()));
+        }
+        current = '';
+        continue;
+      }
+    }
+
+    current += char;
+  }
+
+  if (current.trim()) {
+    params.push(parseCodegenParameter(current.trim()));
+  }
+
+  return params;
+}
+
+function parseCodegenParameter(param: string): {
+  name: string;
+  type: string;
+  fullType?: string;
+} {
+  // Handle common codegen parameter patterns
+  param = param.trim();
+
+  // std::function<void(type)> const & callback -> callback parameter
+  if (param.includes('std::function')) {
+    // Extract the function name from the end
+    const parts = param.split(/\s+/);
+    let name = parts[parts.length - 1].replace(/[&*]/g, '');
+
+    // If name contains 'const', get the previous part
+    if (name.includes('const')) {
+      name = parts[parts.length - 2] || 'callback';
+    }
+
+    // Preserve the full function type for accurate generation
+    return {
+      name: name || 'callback',
+      type: 'function',
+      fullType: param,
+    };
+  }
+
+  // Extract parameter name from the end
+  const parts = param.split(/\s+/);
+  let name = parts[parts.length - 1].replace(/[&*]/g, ''); // Remove references/pointers
+
+  // Handle winrt types and const references
+  if (name.includes('const')) {
+    name = parts[parts.length - 2] || 'param';
+  }
+
+  // Map common codegen types
+  let type = 'any';
+  if (param.includes('std::string') || param.includes('winrt::hstring')) {
+    type = 'string';
+  } else if (param.includes('double') || param.includes('float')) {
+    type = 'number';
+  } else if (param.includes('bool')) {
+    type = 'boolean';
+  } else if (
+    param.includes('int32_t') ||
+    param.includes('int64_t') ||
+    param.includes('int')
+  ) {
+    type = 'number';
+  } else if (param.includes('JSValue')) {
+    type = 'any';
+  } else if (param.includes('winrt::')) {
+    type = 'string'; // Most winrt types are strings or can be treated as such
+  }
+
+  return {name: name || 'param', type, fullType: param};
+}
+
+function parseCodegenSignature(
+  signature: string,
+): {name: string; type: string; fullType?: string}[] {
+  // Parse Method<void(...)> signature to extract parameters
+  const paramMatch = signature.match(/void\s*\(([^)]*)\)/);
+  if (!paramMatch) {
+    return [];
+  }
+
+  return parseCodegenParameters(paramMatch[1]);
+}
+
+function mapTSToCppType(tsType: string): string {
+  const typeMap: {[key: string]: string} = {
+    string: 'std::string',
+    number: 'double',
+    boolean: 'bool',
+    object: 'React::JSValue',
+    any: 'React::JSValue',
+    'any[]': 'React::JSValueArray',
+    void: 'void',
+    Double: 'double', // React Native codegen type
+    Int32: 'int32_t', // React Native codegen type
+    Float: 'float', // React Native codegen type
+  };
+
+  // Handle array types
+  if (tsType.endsWith('[]')) {
+    const baseType = tsType.slice(0, -2);
+    const cppBaseType = typeMap[baseType] || 'React::JSValue';
+    return `std::vector<${cppBaseType}>`;
+  }
+
+  return typeMap[tsType] || 'React::JSValue';
+}
+
+function generateDefaultValue(returnType: string): string {
+  if (returnType === 'string') {
+    return '"example"';
+  } else if (returnType === 'number') {
+    return '0';
+  } else if (returnType === 'boolean') {
+    return 'false';
+  } else {
+    return 'React::JSValue{}';
+  }
+}
+
+async function generateHeaderStub(
+  moduleName: string,
+  methods: MethodSignature[],
+): Promise<string> {
+  const namespace = `${moduleName}Specs`;
+  const codegenNamespace = `${moduleName}Codegen`;
+
+  // Add hello world method first
+  const helloWorldMethod = `  REACT_METHOD(helloWorld)
+  void helloWorld() noexcept;`;
+
+  const methodDeclarations = methods
+    .map(method => {
+      const cppParams = method.parameters
+        .map(p => {
+          if (p.type === 'function') {
+            // Use the full type if available, otherwise fallback to simplified version
+            if (p.fullType) {
+              return p.fullType;
+            }
+            // Handle callback functions from codegen
+            if (p.name.includes('onSuccess') || p.name === 'callback') {
+              return `std::function<void()> const & ${p.name}`;
+            } else if (p.name.includes('onError')) {
+              return `std::function<void(::React::JSValue const &)> const & ${p.name}`;
+            } else {
+              return `std::function<void()> const & ${p.name}`;
+            }
+          } else {
+            let cppType = mapTSToCppType(p.type);
+            // Use winrt::hstring for string parameters to match Windows conventions
+            if (p.type === 'string') {
+              cppType = 'winrt::hstring const&';
+            }
+            return `${cppType} ${p.name}`;
+          }
+        })
+        .join(', ');
+
+      // Determine if this is a getter method (no parameters and non-void return type)
+      const isGetter =
+        method.parameters.length === 0 && method.returnType !== 'void';
+      const returnType = isGetter ? mapTSToCppType(method.returnType) : 'void';
+      const constModifier = isGetter ? ' const' : '';
+
+      return `  REACT_METHOD(${method.name})
+  ${returnType} ${method.name}(${cppParams}) noexcept${constModifier};`;
+    })
+    .join('\n\n');
+
+  // Combine hello world with parsed methods
+  const allMethodDeclarations = methodDeclarations
+    ? [helloWorldMethod, methodDeclarations].join('\n\n')
+    : helloWorldMethod;
+
+  const defaultMethods = allMethodDeclarations;
+
+  return `#pragma once
+
+#include "pch.h"
+#include "resource.h"
+
+#if __has_include("codegen/Native${moduleName}DataTypes.g.h")
+  #include "codegen/Native${moduleName}DataTypes.g.h"
+#endif
+#include "codegen/Native${moduleName}Spec.g.h"
+
+#include "NativeModules.h"
+
+namespace winrt::${namespace}
+{
+
+// See https://microsoft.github.io/react-native-windows/docs/native-platform for help writing native modules
+
+REACT_MODULE(${moduleName})
+struct ${moduleName}
+{
+  using ModuleSpec = ${codegenNamespace}::${moduleName}Spec;
+
+  REACT_INIT(Initialize)
+  void Initialize(React::ReactContext const &reactContext) noexcept;
+
+${defaultMethods}
+
+private:
+  React::ReactContext m_context;
+};
+
+} // namespace winrt::${namespace}`;
+}
+
+async function generateCppStub(
+  moduleName: string,
+  methods: MethodSignature[],
+): Promise<string> {
+  const namespace = `${moduleName}Specs`;
+
+  // Add hello world implementation first
+  const helloWorldImplementation = `void ${moduleName}::helloWorld() noexcept {
+  // Log a welcome message using Windows console
+  OutputDebugStringA("Hello, world! Welcome to the ${moduleName} module!\\n");
+}`;
+
+  const methodImplementations = methods
+    .map(method => {
+      const cppParams = method.parameters
+        .map(p => {
+          if (p.type === 'function') {
+            // Use the full type if available, otherwise fallback to simplified version
+            if (p.fullType) {
+              return p.fullType;
+            }
+            // Handle callback functions from codegen
+            if (p.name.includes('onSuccess') || p.name === 'callback') {
+              return `std::function<void()> const & ${p.name}`;
+            } else if (
+              p.name.includes('onError') ||
+              p.name.includes('reject')
+            ) {
+              return `std::function<void(::React::JSValue const &)> const & ${p.name}`;
+            } else {
+              return `std::function<void()> const & ${p.name}`;
+            }
+          } else {
+            let cppType = mapTSToCppType(p.type);
+            // Use winrt::hstring for string parameters to match Windows conventions
+            if (p.type === 'string') {
+              cppType = 'winrt::hstring const&';
+            }
+            return `${cppType} ${p.name}`;
+          }
+        })
+        .join(', ');
+
+      // Determine if this is a getter method (no parameters and non-void return type)
+      const isGetter =
+        method.parameters.length === 0 && method.returnType !== 'void';
+      const returnType = isGetter ? mapTSToCppType(method.returnType) : 'void';
+      const constModifier = isGetter ? ' const' : '';
+
+      // Generate implementation based on method type
+      const hasCallback = method.parameters.some(
+        p =>
+          p.type === 'function' &&
+          (p.name.includes('onSuccess') || p.name === 'callback'),
+      );
+      const hasErrorCallback = method.parameters.some(
+        p =>
+          p.type === 'function' &&
+          (p.name.includes('onError') || p.name.includes('reject')),
+      );
+
+      let implementation = `  // TODO: Implement ${method.name}`;
+
+      if (isGetter) {
+        // Getter method - return default value
+        const defaultValue = generateDefaultValue(method.returnType);
+        implementation += `\n  return ${defaultValue};`;
+      } else if (hasCallback && hasErrorCallback) {
+        // Method with success and error callbacks
+        implementation += `\n  // Example: callback(); // Call on success\n  // Example: onError(React::JSValue{"Error message"}); // Call on error`;
+      } else if (hasCallback) {
+        // Method with just callback
+        implementation += `\n  // Example: callback(); // Call when complete`;
+      }
+
+      return `${returnType} ${moduleName}::${method.name}(${cppParams}) noexcept${constModifier} {
+${implementation}
+}`;
+    })
+    .join('\n\n');
+
+  // Combine hello world with parsed method implementations
+  const allImplementations = methodImplementations
+    ? [helloWorldImplementation, methodImplementations].join('\n\n')
+    : helloWorldImplementation;
+
+  return `#include "${moduleName}.h"
+
+namespace winrt::${namespace} {
+
+void ${moduleName}::Initialize(React::ReactContext const &reactContext) noexcept {
+  m_context = reactContext;
+}
+
+${allImplementations}
+
+} // namespace winrt::${namespace}
+`;
+}
diff --git a/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/validationUtils.ts b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/validationUtils.ts
new file mode 100644
index 00000000000..0e70ceda1f4
--- /dev/null
+++ b/packages/@react-native-windows/cli/src/commands/setupModuleWindows/utils/validationUtils.ts
@@ -0,0 +1,175 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+import path from 'path';
+import {execSync} from 'child_process';
+import glob from 'glob';
+
+import fs from '@react-native-windows/fs';
+import {CodedError} from '@react-native-windows/telemetry';
+
+export async function validateEnvironment(
+  root: string,
+  logging: boolean,
+): Promise<void> {
+  if (logging) {
+    console.log('[SetupModuleWindows] Validating environment...');
+  }
+
+  // Check if package.json exists
+  const packageJsonPath = path.join(root, 'package.json');
+  if (!(await fs.exists(packageJsonPath))) {
+    throw new CodedError(
+      'NoPackageJson',
+      'No package.json found. Make sure you are in a React Native project directory.',
+    );
+  }
+
+  // Check if it's a valid npm package
+  try {
+    const pkgJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
+    if (!pkgJson.name) {
+      throw new CodedError(
+        'NoProjectName',
+        'package.json must have a "name" field.',
+      );
+    }
+    if (logging) {
+      console.log(`[SetupModuleWindows] Project name: ${pkgJson.name}`);
+    }
+  } catch (error: any) {
+    if (error.code === 'NoProjectName') {
+      throw error;
+    }
+    throw new CodedError('NoPackageJson', 'package.json is not valid JSON.');
+  }
+
+  // Check if yarn is available
+  try {
+    execSync('yarn --version', {stdio: 'ignore'});
+    if (logging) {
+      console.log('[SetupModuleWindows] Yarn found');
+    }
+  } catch {
+    throw new CodedError(
+      'Unknown',
+      'Yarn is required but not found. Please install Yarn first.',
+    );
+  }
+}
+
+export async function checkForExistingSpec(
+  root: string,
+  logging: boolean,
+): Promise<{validSpecFiles: string[]; actualModuleName?: string}> {
+  if (logging) {
+    console.log('[SetupModuleWindows] Checking for TurboModule spec file...');
+  }
+
+  // Look for spec files in common locations, excluding node_modules
+  const specPatterns = [
+    'Native*.[jt]s',
+    'src/**/Native*.[jt]s',
+    'lib/**/Native*.[jt]s',
+    'js/**/Native*.[jt]s',
+    'ts/**/Native*.[jt]s',
+  ];
+
+  const specFiles: string[] = [];
+  for (const pattern of specPatterns) {
+    const matches = glob.sync(pattern, {
+      cwd: root,
+      ignore: ['**/node_modules/**', '**/build/**', '**/dist/**'],
+    });
+    specFiles.push(...matches);
+  }
+
+  // Remove duplicates and filter for actual TurboModule specs
+  const uniqueSpecFiles = Array.from(new Set(specFiles));
+  const validSpecFiles = await filterValidSpecFiles(uniqueSpecFiles, root);
+
+  if (validSpecFiles.length === 0) {
+    throw new CodedError(
+      'NoTurboModuleSpec',
+      'Create Spec File - TurboModule spec file not found. Please create a TurboModule spec file before running setup-module-windows.',
+    );
+  } else {
+    if (logging) {
+      console.log(
+        `[SetupModuleWindows] Found valid spec file(s): ${validSpecFiles.join(
+          ', ',
+        )}`,
+      );
+    }
+    const actualModuleName = await extractModuleNameFromExistingSpec(
+      validSpecFiles[0],
+      root,
+    );
+    return {validSpecFiles, actualModuleName};
+  }
+}
+
+async function filterValidSpecFiles(
+  specFiles: string[],
+  root: string,
+): Promise<string[]> {
+  const validFiles: string[] = [];
+
+  for (const file of specFiles) {
+    try {
+      const filePath = path.join(root, file);
+      const content = await fs.readFile(filePath, 'utf8');
+
+      if (isValidTurboModuleSpec(content)) {
+        validFiles.push(file);
+      }
+    } catch (error) {
+      // Skip files that can't be read
+      continue;
+    }
+  }
+
+  return validFiles;
+}
+
+function isValidTurboModuleSpec(content: string): boolean {
+  // Check for TurboModule spec patterns
+  const turboModulePatterns = [
+    /TurboModule/,
+    /export\s+interface\s+Spec/,
+    /export\s+default\s+TurboModuleRegistry/,
+  ];
+
+  return turboModulePatterns.some(pattern => pattern.test(content));
+}
+
+async function extractModuleNameFromExistingSpec(
+  specFile: string,
+  root: string,
+): Promise<string | undefined> {
+  try {
+    const filePath = path.join(root, specFile);
+    const content = await fs.readFile(filePath, 'utf8');
+
+    // Try to extract module name from export default TurboModuleRegistry.get<Spec>('ModuleName')
+    const registryMatch = content.match(
+      /TurboModuleRegistry\.get(?:Enforcing)?<[^>]+>\(\s*['"`]([^'"`]+)['"`]\s*\)/,
+    );
+    if (registryMatch) {
+      return registryMatch[1];
+    }
+
+    // Fallback: extract from filename (remove Native prefix and file extension)
+    const fileName = path.basename(specFile, path.extname(specFile));
+    if (fileName.startsWith('Native')) {
+      return fileName.slice(6); // Remove "Native" prefix
+    }
+
+    return fileName;
+  } catch (error) {
+    return undefined;
+  }
+}
diff --git a/packages/@react-native-windows/cli/src/index.ts b/packages/@react-native-windows/cli/src/index.ts
index 7cae7a0e285..c21485ef307 100644
--- a/packages/@react-native-windows/cli/src/index.ts
+++ b/packages/@react-native-windows/cli/src/index.ts
@@ -18,6 +18,7 @@ import {autolinkCommand} from './commands/autolinkWindows/autolinkWindows';
 import {codegenCommand} from './commands/codegenWindows/codegenWindows';
 import {initCommand} from './commands/initWindows/initWindows';
 import {runWindowsCommand} from './commands/runWindows/runWindows';
+import {setupModuleWindowsCommand} from './commands/setupModuleWindows/setupModuleWindows';
 import {dependencyConfigWindows} from './commands/config/dependencyConfig';
 import {projectConfigWindows} from './commands/config/projectConfig';
 
@@ -99,7 +100,9 @@ export const commands = [
   codegenCommand,
   initCommand,
   runWindowsCommand,
+  setupModuleWindowsCommand,
 ];
 export const dependencyConfig = dependencyConfigWindows;
 export const projectConfig = projectConfigWindows;
+export {setupModuleWindowsInternal} from './commands/setupModuleWindows/setupModuleWindows';
 export * from './commands/healthCheck/healthChecks';
diff --git a/packages/@react-native-windows/telemetry/src/utils/errorUtils.ts b/packages/@react-native-windows/telemetry/src/utils/errorUtils.ts
index 570ea0ea04c..f6fdb8100a4 100644
--- a/packages/@react-native-windows/telemetry/src/utils/errorUtils.ts
+++ b/packages/@react-native-windows/telemetry/src/utils/errorUtils.ts
@@ -77,6 +77,9 @@ export const CodedErrors = {
   NoProjectName: 5003,
   InvalidProjectName: 5004,
   InvalidProjectNamespace: 5005,
+
+  // setup-module-windows
+  NoTurboModuleSpec: 6000,
 };
 
 export type CodedErrorType = keyof typeof CodedErrors;