@babajide234/git-merge-workflow 1.0.0

package/.github/workflows/npm-publish-github-packages.yml

@@ -0,0 +1,36 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+      - run: npm ci
+      - run: npm test
+
+  publish-gpr:
+    needs: build
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          registry-url: https://npm.pkg.github.com/
+      - run: npm ci
+      - run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}

package/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish PowerShell Module
+
+on:
+  release:
+    types: [created]
+  workflow_dispatch:
+
+jobs:
+  publish-to-gallery:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Build and Publish
+        env:
+          NUGET_KEY: ${{ secrets.NUGET_KEY }}
+        shell: pwsh
+        run: |
+          Publish-Module -Path . -NuGetApiKey $env:NUGET_KEY -Verbose
+
+  publish-to-npm:
+    runs-on: ubuntu-latest
+    needs: publish-to-gallery
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: '16.x'
+          registry-url: 'https://registry.npmjs.org'
+      
+      - run: npm install
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/DEVELOPER_GUIDE.md

@@ -0,0 +1,96 @@
+# Developer Guide: Git Merge Workflow (GMW)
+
+This guide explains how the **Git Merge Workflow** PowerShell module works and how you can modify it.
+
+## 📂 Project Structure
+
+The module is located at:
+`c:\Users\jyde2\OneDrive\Documents\WindowsPowerShell\Modules\GitMergeWorkflow`
+
+- **GitMergeWorkflow.psd1**: The *Module Manifest*. Contains metadata (version, author, description) and defines which files are processed when the module is imported.
+- **GitMergeWorkflow.psm1**: The *Script Module*. Contains the actual source code and logic for the functions. **This is where you will make most changes.**
+- **Install.ps1**: A helper script to install the module on a new machine.
+- **package.json**: configuration for NPM publishing (if applicable).
+
+## 🧠 How It Works
+
+The core logic resides in `GitMergeWorkflow.psm1`.
+
+### Main Function: `Invoke-GitMergeWorkflow`
+This is the function executed when you run `gmw`.
+
+1.  **Configuration Loading**:
+    - Calls `Get-GitWorkflowConfig` to look for a `.git-merge-workflow.json` file in your repository root.
+    - Sets defaults (`develop` for target, `-staging` for suffix) if no config is found.
+
+2.  **Environment Checks**:
+    - Checks if `git` is available and if the current directory is a git repository.
+    - Validates that you are NOT currently on the target branch (e.g., `develop`) or the staging branch.
+
+3.  **Staging Phase**:
+    - Determines the staging branch name (e.g., `feature-xyz-staging`).
+    - Checks if the staging branch exists locally or remotely.
+    - **Merges** your current feature branch into this staging branch.
+    - **Pushes** the staging branch to the remote (`origin`).
+        - *Recent Update*: This step now includes error handling. If the push fails (e.g., permissions issue), it asks if you want to skip and proceed.
+
+4.  **Target Phase**:
+    - Checkouts the target branch (`develop`).
+    - Pulls the latest changes.
+    - **Merges** the staging branch into the target branch.
+    - **Pushes** the target branch to remote.
+
+5.  **Cleanup**:
+    - Returns you to your original feature branch.
+
+### Helper Functions
+- `Exec-Git`: A wrapper around git commands to handle errors and verbose output consistently.
+- `New-GitWorkflowConfig`: Generates the JSON configuration file.
+
+## 🛠️ How to Edit and Test
+
+Since this is a PowerShell module, changes are not picked up immediately if the module is already loaded in your session.
+
+### 1. Edit the Code
+Open `GitMergeWorkflow.psm1` in VS Code or your preferred editor.
+
+**Example**: Adding a new log message.
+```powershell
+# Inside Invoke-GitMergeWorkflow
+Write-Host "Starting my custom workflow..." -ForegroundColor Magenta
+```
+
+### 2. Reload the Module
+After saving your changes, you must reload the module in your PowerShell terminal to see them take effect.
+
+Run this command:
+```powershell
+Import-Module GitMergeWorkflow -Force
+```
+*The `-Force` flag is crucial as it unloads the old version and loads the new one.*
+
+### 3. Test
+Run the command again:
+```powershell
+gmw -WhatIf
+```
+*Using `-WhatIf` (Dry Run) is a safe way to test logic changes without actually running git commands, provided the script supports it (mostly used for ShouldProcess).*
+
+For real testing, just run `gmw` in a test repository.
+
+## 📦 Configuration
+
+The behavior can be customized per-repository using a `.git-merge-workflow.json` file:
+
+```json
+{
+  "TargetBranch": "main",
+  "StagingSuffix": "-qa",
+  "Remote": "upstream"
+}
+```
+
+You can generate this file using:
+```powershell
+New-GitWorkflowConfig
+```

package/GitMergeWorkflow.psd1

@@ -0,0 +1,18 @@
+@{
+    RootModule = 'GitMergeWorkflow.psm1'
+    ModuleVersion = '1.0.0'
+    GUID = 'a1b2c3d4-e5f6-7890-abcd-ef1234567890'
+    Author = 'babajide Tomoshegbo'
+    CompanyName = 'babajide234'
+    Copyright = '(c) 2025 Expedier. All rights reserved.'
+    Description = 'Automated Git workflow for merging feature branches through staging to develop'
+    PowerShellVersion = '5.1'
+    FunctionsToExport = @('Invoke-GitMergeWorkflow', 'New-GitWorkflowConfig', 'Get-GitWorkflowConfig')
+    AliasesToExport = @('git-merge-workflow', 'gmw')
+    PrivateData = @{
+        PSData = @{
+            Tags = @('Git', 'Workflow', 'Automation', 'Merge', 'DevOps')
+            ProjectUri = 'https://github.com/babajide234/GitMergeWorkflow'
+        }
+    }
+}

package/GitMergeWorkflow.psm1

@@ -0,0 +1,343 @@
+
+function Get-GitWorkflowConfig {
+    <#
+    .SYNOPSIS
+        Retrieves the Git Merge Workflow configuration from the current repository
+    .DESCRIPTION
+        Looks for a .git-merge-workflow.json file in the root of the git repository.
+        If found, parses and returns the configuration.
+        If not found, returns null.
+    #>
+    [CmdletBinding()]
+    param()
+
+    try {
+        # Get git root
+        $gitRoot = git rev-parse --show-toplevel 2>$null
+        if ($LASTEXITCODE -eq 0 -and $gitRoot) {
+            $configPath = Join-Path $gitRoot ".git-merge-workflow.json"
+            if (Test-Path $configPath) {
+                return Get-Content $configPath -Raw | ConvertFrom-Json
+            }
+        }
+    } catch {
+        Write-Verbose "Error reading config: $_"
+    }
+    return $null
+}
+
+function New-GitWorkflowConfig {
+    <#
+    .SYNOPSIS
+        Creates a new configuration file for the Git Merge Workflow
+    .DESCRIPTION
+        Creates a .git-merge-workflow.json file in the root of the current git repository.
+    .PARAMETER TargetBranch
+        The default target branch (default: develop)
+    .PARAMETER StagingSuffix
+        The suffix for staging branches (default: -staging)
+    .PARAMETER Remote
+        The default remote name (default: origin)
+    .EXAMPLE
+        New-GitWorkflowConfig -TargetBranch "main" -StagingSuffix "-test"
+    #>
+    [CmdletBinding(SupportsShouldProcess=$true)]
+    param(
+        [string]$TargetBranch = "develop",
+        [string]$StagingSuffix = "-staging",
+        [string]$Remote = "origin"
+    )
+
+    # Check if in git repo
+    $gitRoot = git rev-parse --show-toplevel 2>$null
+    if ($LASTEXITCODE -ne 0 -or -not $gitRoot) {
+        Write-Error "Not in a git repository. Please run inside a git repository."
+        return
+    }
+
+    $configPath = Join-Path $gitRoot ".git-merge-workflow.json"
+    
+    $config = @{
+        TargetBranch = $TargetBranch
+        StagingSuffix = $StagingSuffix
+        Remote = $Remote
+    }
+
+    $json = $config | ConvertTo-Json -Depth 2
+
+    if ($PSCmdlet.ShouldProcess($configPath, "Create configuration file")) {
+        $json | Set-Content $configPath
+        Write-Host "Configuration file created at: $configPath" -ForegroundColor Green
+        Write-Host "Content:" -ForegroundColor Cyan
+        Write-Host $json
+    }
+}
+
+function Invoke-GitMergeWorkflow {
+    <#
+    .SYNOPSIS
+        Automated Git workflow to merge current branch to staging and then to develop
+    .DESCRIPTION
+        This function automates the process of:
+        1. Getting the current branch name
+        2. Merging current branch to {branch}-staging
+        3. Merging {branch}-staging to develop
+        4. Pushing all changes
+        
+        Configuration can be stored in .git-merge-workflow.json in the repository root.
+    .PARAMETER CommitMessage
+        Optional commit message if there are uncommitted changes
+    .PARAMETER StagingBranch
+        Optional custom staging branch name.
+        Defaults to {current-branch}{staging-suffix} (configured in JSON or defaults to -staging)
+    .PARAMETER TargetBranch
+        Optional target branch name.
+        Defaults to 'develop' or value in configuration file.
+    .PARAMETER Remote
+        Optional remote name.
+        Defaults to 'origin' or value in configuration file.
+    .EXAMPLE
+        Invoke-GitMergeWorkflow
+    .EXAMPLE
+        Invoke-GitMergeWorkflow -CommitMessage "Fix: Updated business contact form"
+    .EXAMPLE
+        git-merge-workflow -CommitMessage "Feature: Added new component" -WhatIf
+    #>
+    
+    [CmdletBinding(SupportsShouldProcess=$true)]
+    param(
+        [Parameter(Mandatory=$false)]
+        [string]$CommitMessage = "",
+        
+        [Parameter(Mandatory=$false)]
+        [string]$StagingBranch = "",
+        
+        [Parameter(Mandatory=$false)]
+        [string]$TargetBranch = "",
+
+        [Parameter(Mandatory=$false)]
+        [string]$Remote = ""
+    )
+    
+    # Load configuration
+    $config = Get-GitWorkflowConfig
+    
+    # Set defaults (Priority: Parameter > Config > Hardcoded Default)
+    if (-not $TargetBranch) {
+        $TargetBranch = if ($config.TargetBranch) { $config.TargetBranch } else { "develop" }
+    }
+    
+    if (-not $Remote) {
+        $Remote = if ($config.Remote) { $config.Remote } else { "origin" }
+    }
+    
+    $stagingSuffix = if ($config.StagingSuffix) { $config.StagingSuffix } else { "-staging" }
+
+    # Internal helper to execute git commands with error handling
+    function Exec-Git {
+        [CmdletBinding()]
+        param(
+            [Parameter(Mandatory=$true, Position=0)]
+            [string]$Command,
+
+            [Parameter(Mandatory=$false)]
+            [string]$ErrorMessage,
+
+            [Parameter(Mandatory=$false)]
+            [switch]$IgnoreError,
+
+            [Parameter(Mandatory=$false)]
+            [switch]$ReturnOutput,
+
+            [Parameter(ValueFromRemainingArguments=$true)]
+            [string[]]$Arguments
+        )
+
+        $cmdDesc = "git $Command $Arguments"
+        
+        if ($PSCmdlet.ShouldProcess("Git Repository", "Execute: $cmdDesc")) {
+            # Construct the command to run
+            # Note: We use & operator to run git with arguments
+            $output = & git $Command $Arguments 2>&1
+            $exitCode = $LASTEXITCODE
+
+            if ($ReturnOutput) {
+                return $output
+            } elseif ($output) {
+                # If not capturing output, write it to the stream (except errors which we handle below)
+                $output | ForEach-Object { Write-Verbose $_ }
+            }
+
+            if (-not $IgnoreError -and $exitCode -ne 0) {
+                $msg = if ($ErrorMessage) { $ErrorMessage } else { "Git command failed: $cmdDesc" }
+                throw "$msg`nDetails: $output"
+            }
+        }
+    }
+
+    Write-Host "`n=== Git Merge Workflow ===" -ForegroundColor Cyan
+    Write-Host "Starting automated merge process...`n" -ForegroundColor Cyan
+    
+    # Check if we're in a git repository
+    try {
+        Exec-Git "rev-parse" "--is-inside-work-tree" -ErrorMessage "Not a git repository" -ReturnOutput | Out-Null
+    } catch {
+        Write-Error $_.Exception.Message
+        return
+    }
+    
+    # Get current branch
+    $currentBranch = (git branch --show-current).Trim()
+    Write-Host "Current branch: $currentBranch" -ForegroundColor Yellow
+    
+    if ([string]::IsNullOrWhiteSpace($currentBranch)) {
+        Write-Error "Could not determine current branch."
+        return
+    }
+
+    # Validate we are not on target or explicitly named staging
+    if ($currentBranch -eq $TargetBranch) {
+        Write-Error "You are currently on the target branch '$TargetBranch'. Please checkout your feature branch first."
+        return
+    }
+
+    # Define staging branch
+    if (-not $StagingBranch) {
+        $StagingBranch = "$currentBranch$stagingSuffix"
+    }
+
+    if ($currentBranch -eq $StagingBranch) {
+        Write-Error "You are currently on the staging branch '$StagingBranch'. Please checkout your feature branch first."
+        return
+    }
+
+    Write-Host "`nStaging branch: $StagingBranch" -ForegroundColor Yellow
+    Write-Host "Target branch:  $TargetBranch" -ForegroundColor Yellow
+    Write-Host "Remote:         $Remote" -ForegroundColor Yellow
+    
+    # Store starting branch to return to it later
+    $originalBranch = $currentBranch
+
+    try {
+        # Verify remote connection before proceeding
+        Write-Host "`nVerifying connection to $Remote..." -ForegroundColor Yellow
+        Exec-Git -Command "ls-remote" -Arguments $Remote, "HEAD" -ErrorMessage "Could not connect to remote '$Remote'. Please check your internet connection and git credentials." -ReturnOutput | Out-Null
+        Write-Host "Connection successful!" -ForegroundColor Green
+
+        # Check for uncommitted changes
+        $status = git status --porcelain
+        if ($status) {
+            if ($CommitMessage) {
+                Write-Host "`nCommitting changes..." -ForegroundColor Yellow
+                if ($PSCmdlet.ShouldProcess("Current Branch", "Add all changes and commit with message '$CommitMessage'")) {
+                    Exec-Git "add" "." -ErrorMessage "Failed to add changes"
+                    Exec-Git "commit" "-m" "$CommitMessage" -ErrorMessage "Failed to commit changes"
+                    Write-Host "Changes committed!" -ForegroundColor Green
+                }
+            } else {
+                Write-Error "You have uncommitted changes! Please commit them first or use -CommitMessage parameter"
+                git status
+                return
+            }
+        }
+        
+        # --- Handle Staging Branch ---
+
+        # Check if staging branch exists locally
+        $branchExists = git branch --list $StagingBranch
+        if (-not $branchExists) {
+            Write-Host "`nStaging branch doesn't exist locally. Checking remote..." -ForegroundColor Yellow
+            # Check if exists on remote (explicit check to avoid silent failures)
+            $remoteBranchExists = $false
+            try {
+                $lsRemote = Exec-Git -Command "ls-remote" -Arguments "--heads", $Remote, $StagingBranch -ReturnOutput
+                if ($lsRemote) { $remoteBranchExists = $true }
+            } catch {
+                Write-Warning "Could not check remote branch: $_"
+            }
+            
+            if ($remoteBranchExists) {
+                Write-Host "Fetching remote staging branch..." -ForegroundColor Yellow
+                Exec-Git -Command "fetch" -Arguments $Remote, $StagingBranch
+                Exec-Git -Command "checkout" -Arguments "-b", $StagingBranch, "$Remote/$StagingBranch"
+            } else {
+                Write-Host "Creating new staging branch..." -ForegroundColor Yellow
+                Exec-Git -Command "checkout" -Arguments "-b", $StagingBranch
+            }
+        } else {
+            Write-Host "Checking out staging branch..." -ForegroundColor Yellow
+            Exec-Git -Command "checkout" -Arguments $StagingBranch
+        }
+        
+        # Pull latest from staging (if tracked)
+        Write-Host "`nPulling latest changes from staging..." -ForegroundColor Yellow
+        # We use IgnoreError because it might fail if there's no tracking info yet, which is acceptable here
+        Exec-Git -Command "pull" -Arguments $Remote, $StagingBranch -IgnoreError
+        
+        # Merge current branch into staging
+        Write-Host "`nMerging $currentBranch into $StagingBranch..." -ForegroundColor Yellow
+        Exec-Git -Command "merge" -Arguments $currentBranch, "--no-ff", "-m", "Merge $currentBranch into $StagingBranch" -ErrorMessage "Merge conflict detected in staging! Please resolve conflicts manually."
+        
+        Write-Host "Successfully merged to staging!" -ForegroundColor Green
+        
+        # Push staging
+        Write-Host "`nPushing $StagingBranch to remote..." -ForegroundColor Yellow
+        try {
+            Exec-Git -Command "push" -Arguments "-u", $Remote, $StagingBranch -ErrorMessage "Failed to push staging branch"
+            Write-Host "Staging branch pushed!" -ForegroundColor Green
+        } catch {
+            Write-Warning "Failed to push staging branch to remote."
+            Write-Warning "Error: $_"
+            if ($PSCmdlet.ShouldContinue("Do you want to skip pushing the staging branch and continue to merge into $TargetBranch?", "Skip Staging Push")) {
+                Write-Host "Skipping staging push..." -ForegroundColor Yellow
+            } else {
+                throw $_
+            }
+        }
+        
+        # --- Handle Target Branch ---
+
+        # Checkout target branch
+        Write-Host "`nChecking out $TargetBranch branch..." -ForegroundColor Yellow
+        Exec-Git "checkout" $TargetBranch -ErrorMessage "Failed to checkout $TargetBranch"
+        
+        # Pull latest from target
+        Write-Host "Pulling latest changes from $TargetBranch..." -ForegroundColor Yellow
+        Exec-Git "pull" $Remote $TargetBranch -ErrorMessage "Failed to pull $TargetBranch"
+        
+        # Merge staging into target
+        Write-Host "`nMerging $StagingBranch into $TargetBranch..." -ForegroundColor Yellow
+        Exec-Git "merge" $StagingBranch "--no-ff" "-m" "Merge $StagingBranch into $TargetBranch" -ErrorMessage "Merge conflict detected in target! Please resolve conflicts manually."
+        
+        Write-Host "Successfully merged to target!" -ForegroundColor Green
+        
+        # Push target
+        Write-Host "`nPushing $TargetBranch to remote..." -ForegroundColor Yellow
+        Exec-Git "push" $Remote $TargetBranch -ErrorMessage "Failed to push $TargetBranch branch"
+        Write-Host "$TargetBranch branch pushed!" -ForegroundColor Green
+        
+        Write-Host "`n=== Workflow Complete! ===" -ForegroundColor Green
+        Write-Host "Summary:" -ForegroundColor Cyan
+        Write-Host "  ✓ Merged: $originalBranch → $StagingBranch → $TargetBranch" -ForegroundColor White
+        Write-Host "  ✓ All changes pushed to remote`n" -ForegroundColor White
+
+    } catch {
+        Write-Error $_.Exception.Message
+        Write-Host "`nWorkflow failed. Attempting to return to original branch..." -ForegroundColor Red
+    } finally {
+        # Return to original branch
+        $finalBranch = (git branch --show-current).Trim()
+        if ($originalBranch -and $finalBranch -ne $originalBranch) {
+            Write-Host "`nReturning to $originalBranch..." -ForegroundColor Yellow
+            if ($PSCmdlet.ShouldProcess("Cleanup", "Checkout $originalBranch")) {
+                git checkout $originalBranch 2>$null | Out-Null
+            }
+        }
+    }
+}
+
+# Create aliases for easier usage
+New-Alias -Name git-merge-workflow -Value Invoke-GitMergeWorkflow -Force
+New-Alias -Name gmw -Value Invoke-GitMergeWorkflow -Force
+
+Export-ModuleMember -Function Invoke-GitMergeWorkflow, New-GitWorkflowConfig, Get-GitWorkflowConfig -Alias git-merge-workflow, gmw

package/Install.ps1

@@ -0,0 +1,31 @@
+# Simple installation script for GitMergeWorkflow module
+
+$moduleName = "GitMergeWorkflow"
+$currentUserModules = [System.IO.Path]::Combine($env:USERPROFILE, "Documents", "WindowsPowerShell", "Modules")
+$destPath = Join-Path $currentUserModules $moduleName
+
+Write-Host "Installing $moduleName to $destPath..." -ForegroundColor Cyan
+
+# Create modules directory if it doesn't exist
+if (-not (Test-Path $currentUserModules)) {
+    New-Item -Path $currentUserModules -ItemType Directory -Force | Out-Null
+}
+
+# Copy module files
+$scriptPath = $PSScriptRoot
+if (-not $scriptPath) { $scriptPath = Get-Location }
+
+if (Test-Path $destPath) {
+    Write-Warning "Module already exists. Updating..."
+    Remove-Item $destPath -Recurse -Force
+}
+
+Copy-Item -Path $scriptPath -Destination $destPath -Recurse -Force
+
+# Verify installation
+if (Test-Path (Join-Path $destPath "$moduleName.psd1")) {
+    Write-Host "Installation successful!" -ForegroundColor Green
+    Write-Host "You can now run: Import-Module $moduleName" -ForegroundColor Yellow
+} else {
+    Write-Error "Installation failed."
+}

package/PUBLISHING.md

@@ -0,0 +1,41 @@
+# How to Publish `@babajide234/git-merge-workflow` to npm
+
+## Prerequisites
+
+1.  **NPM Account**: You must have an account on [npmjs.com](https://www.npmjs.com/).
+2.  **Login**: You must be logged in as `babajide234`.
+
+## Publishing Steps
+
+1.  **Login to npm**:
+    Open your terminal in the project directory and run:
+    ```bash
+    npm login
+    ```
+    Follow the prompts to authenticate via the browser.
+
+2.  **Verify Configuration**:
+    Ensure `package.json` has the correct version.
+    Current version: `1.0.0`
+
+3.  **Publish**:
+    By default, scoped packages (`@org/pkg`) are published as **private**.
+
+    - **To publish publicly** (visible to everyone):
+      ```bash
+      npm publish --access public
+      ```
+
+    - **To publish privately** (only visible to org members - requires paid npm plan):
+      ```bash
+      npm publish
+      ```
+
+## Post-Publishing
+
+-   **Update Version**: For future updates, remember to bump the version number in `package.json` (e.g., `1.0.1`) before publishing again.
+    ```bash
+    npm version patch  # 1.0.0 -> 1.0.1
+    npm version minor  # 1.0.0 -> 1.1.0
+    npm version major  # 1.0.0 -> 2.0.0
+    ```

package/README.md

@@ -0,0 +1,112 @@
+# Git Merge Workflow PowerShell Module
+
+Automate your git merge workflow with safety and ease. This module helps you merge your current feature branch to a staging branch (e.g., `feature-branch-staging`), and then to a target branch (e.g., `develop`), ensuring a consistent workflow.
+
+## Features
+
+- **Automated Merging**: Merges current branch -> Staging -> Target.
+- **Safety Checks**: Prevents running on wrong branches, checks for uncommitted changes.
+- **Conflict Handling**: Stops immediately on merge conflicts so you can resolve them.
+- **Automatic Cleanup**: Returns you to your original branch even if the script fails.
+- **Configurable**: Define project-specific settings via a JSON configuration file.
+- **Dry Run**: Support for `-WhatIf` to preview actions.
+
+## Installation
+
+### Via NPM (Recommended for Node.js users)
+You can install this tool globally using npm:
+
+```bash
+npm install -g @expedier/git-merge-workflow
+```
+This will make the `gmw` and `git-merge-workflow` commands available in your terminal.
+
+### Manual Installation
+1. Download this repository.
+2. Run the included installation script:
+   ```powershell
+   .\Install.ps1
+   ```
+   Or copy the `GitMergeWorkflow` folder to your PowerShell modules directory manually.
+3. Import the module (if not auto-loaded):
+   ```powershell
+   Import-Module GitMergeWorkflow
+   ```
+
+## Usage
+
+### Basic Usage
+Run the workflow from your feature branch:
+```powershell
+Invoke-GitMergeWorkflow
+# OR use the alias
+gmw
+```
+
+### With Commit Message
+If you have uncommitted changes, you can commit them as part of the workflow:
+```powershell
+gmw -CommitMessage "Feat: Completed login page"
+```
+
+### Dry Run (Preview)
+See what commands would be executed without actually running them:
+```powershell
+gmw -WhatIf
+```
+
+### Custom Branches
+Override default branches on the fly:
+```powershell
+gmw -TargetBranch "main" -StagingBranch "custom-staging"
+```
+
+## Configuration
+
+You can create a configuration file for your project so you don't have to pass parameters every time.
+
+1. Navigate to your project root.
+2. Run the configuration generator:
+   ```powershell
+   New-GitWorkflowConfig -TargetBranch "main" -StagingSuffix "-test"
+   ```
+   
+   This creates a `.git-merge-workflow.json` file:
+   ```json
+   {
+     "TargetBranch": "main",
+     "StagingSuffix": "-test",
+     "Remote": "origin"
+   }
+   ```
+
+## Publishing (For Maintainers)
+
+### GitHub Actions
+This repository is configured to automatically publish to:
+1. **PowerShell Gallery** (if `NUGET_KEY` secret is set)
+2. **NPM Registry** (if `NPM_TOKEN` secret is set)
+
+When you create a new Release in GitHub.
+
+### Manual Publishing
+
+**To NPM:**
+```bash
+npm login
+npm publish --access public
+```
+
+**To PowerShell Gallery:**
+```powershell
+Publish-Module -Path . -NuGetApiKey <Your-API-Key>
+```
+
+## Functions
+
+- `Invoke-GitMergeWorkflow` (Alias: `gmw`, `git-merge-workflow`): The main workflow command.
+- `New-GitWorkflowConfig`: Generates the `.git-merge-workflow.json` configuration file.
+- `Get-GitWorkflowConfig`: Reads the current configuration.
+
+## License
+MIT

package/bin/cli.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Path to the PowerShell module
+const modulePath = path.resolve(__dirname, '../GitMergeWorkflow.psd1');
+
+// Arguments passed to the CLI
+const args = process.argv.slice(2);
+
+// Construct the PowerShell command
+// We import the module and then invoke the function with passed arguments
+const psCommand = `
+    $ErrorActionPreference = 'Stop'
+    Import-Module '${modulePath}' -Force
+    Invoke-GitMergeWorkflow ${args.join(' ')}
+`;
+
+// Determine which PowerShell executable to use (pwsh for Core, powershell for Windows PowerShell)
+const psExecutable = process.platform === 'win32' ? 'powershell' : 'pwsh';
+
+const child = spawn(psExecutable, ['-NoProfile', '-Command', psCommand], {
+    stdio: 'inherit',
+    shell: true
+});
+
+child.on('exit', (code) => {
+    process.exit(code);
+});

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@babajide234/git-merge-workflow",
+  "version": "1.0.0",
+  "description": "Automated Git workflow for merging feature branches through staging to develop",
+  "main": "index.js",
+  "bin": {
+    "git-merge-workflow": "./bin/cli.js",
+    "gmw": "./bin/cli.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "git",
+    "workflow",
+    "powershell",
+    "automation",
+    "devops"
+  ],
+  "author": "babajide Tomoshegbo",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babajide234/GitMergeWorkflow.git"
+  },
+  "engines": {
+    "node": ">=14"
+  }
+}