DEV Community: Robiul Awal

Understanding Git Branches and Remote Management: A Comprehensive Guide

Robiul Awal — Thu, 10 Oct 2024 14:07:49 +0000

Git is a powerful version control system that allows developers to track changes in their code and collaborate effectively. One of its core features is branching, which helps manage different lines of development. In this blog post, we’ll explore everything you need to know about Git branches, remote branches, pushing and pulling changes, connecting to GitHub, common problems, and the nuances between the main and master branches. We'll also include all commands related to transitioning from the master branch to the main branch.

1. Git Branch Basics

What is a Git Branch?

A branch in Git is essentially a pointer to a specific commit in your repository’s history. By default, Git creates a branch called main (or master in older versions) when you initialize a repository. Branching allows you to work on new features, fix bugs, or experiment with new ideas without affecting the main codebase.

Creating a Branch

To create a new branch, use:

git branch <branch-name>

To switch to that branch, use:

git checkout <branch-name>

You can also create and switch to a new branch in one command:

git checkout -b <branch-name>

Listing Branches

To view all branches in your repository, run:

git branch

Deleting a Branch

To delete a branch that is no longer needed:

git branch -d <branch-name>

Use -D to force delete if the branch has unmerged changes.

2. Git Remote Branches

What are Remote Branches?

Remote branches are references to the state of branches in your remote repositories (e.g., GitHub). They help you track changes made by collaborators.

Listing Remote Branches

To view all remote branches, use:

git branch -r

Fetching Remote Branches

To fetch the latest changes from the remote repository:

git fetch origin

This command updates your remote-tracking branches but does not merge changes into your local branches.

3. Pushing and Pulling Remote Branches

Pushing to a Remote Branch

To push your local branch to a remote repository:

git push origin <branch-name>

This command will create the branch on the remote if it doesn't exist.

Pulling from a Remote Branch

To pull changes from a remote branch into your current branch:

git pull origin <branch-name>

This command fetches changes from the remote branch and merges them into your current branch.

Understanding Merge Conflicts

When you pull changes, you might encounter merge conflicts if changes have been made to the same lines of code. Git will mark the conflicts in the files, and you'll need to resolve them manually before committing the merged changes.

4. Different Types of Branches

Feature Branches

Feature branches are used to develop new features. They help isolate new development from the main codebase until the feature is ready.

Bugfix Branches

These branches are specifically for fixing bugs. They allow developers to address issues without disrupting ongoing feature work.

Release Branches

Release branches prepare for production releases. They help in final testing and bug fixes before merging back into the main branch.

Hotfix Branches

Hotfix branches are for urgent fixes in production. They are typically branched directly from the main branch to quickly address critical issues.

5. Connecting to GitHub

Setting Up Your Repository

Create a GitHub account if you don’t already have one.
Create a new repository on GitHub.
Clone the repository to your local machine:

   git clone https://github.com/username/repo.git

Set your remote origin (if not set):

   git remote add origin https://github.com/username/repo.git

Authenticating with GitHub

To push to your GitHub repository, you may need to set up SSH keys or use a personal access token for HTTPS.

6. Common Problems with Git and GitHub Branches

Merge Conflicts

As previously mentioned, merge conflicts occur when multiple people modify the same line of code. Always pull changes before pushing your work to minimize conflicts.

Detached HEAD State

If you checkout a commit directly (not a branch), you enter a detached HEAD state. To create a new branch from this state:

git checkout -b <new-branch-name>

Forgotten Commits

Sometimes, developers forget to commit their changes. Always remember to check the status of your working directory with:

git status

7. The Main and Master Branch

Main Branch

The main branch is the default branch in a repository and represents the "production-ready" state of the project. By convention, it’s where stable code resides.

Master Branch

Historically, master was the default branch in Git repositories. Many older projects still use this naming convention. However, there’s been a shift in the Git community towards using main for inclusivity reasons.

Transition from Master to Main

As part of the movement to adopt more inclusive language, many repositories have transitioned from using master to main. This change involves updating your local and remote repository settings.

Importance of the Main/Master Branch

Stability: All production-ready code is merged here, making it crucial for team collaboration.
Release Management: New features and bug fixes are merged into the main branch once tested and approved.
Integration: Continuous integration and deployment (CI/CD) processes often rely on the main branch for deployments.

Managing Changes

Always make sure to pull the latest changes from the main or master branch before starting new work:

git pull origin main  # or git pull origin master

8. Commands Related to Transitioning from Master to Main

If you want to rename your master branch to main, follow these steps:

Step 1: Rename the Local Branch

To rename the local master branch to main:

git branch -m master main

Step 2: Push the New Branch to Remote

Next, push the newly renamed branch to the remote repository:

git push -u origin main

Step 3: Update the Default Branch on GitHub

Go to your GitHub repository settings and change the default branch from master to main.

Step 4: Delete the Old Master Branch on Remote

After ensuring that everything is working correctly, you can delete the old master branch from the remote:

git push origin --delete master

Step 5: Update Local Repositories

Inform your team members to update their local repositories. They can do this by fetching the latest branches:

git fetch origin

Then they can switch to the new main branch:

git checkout main

9. Problems Related to Main and Master Branches

Confusion Between Branch Names

One of the main issues that can arise is confusion between main and master, especially in teams or projects transitioning to the new naming convention. Developers may inadvertently push to the wrong branch or expect changes in one branch to be in another.

Merge Conflicts

If both branches (main and master) are actively developed, you may encounter merge conflicts when merging features or changes. It’s crucial to regularly sync changes between these branches.

Legacy Issues

For projects that have not yet transitioned to main, using master can cause problems when collaborating with newer projects. Developers need to be aware of which branch is the primary branch for stability and releases.

Branch Protection Rules

Both main and master branches can have branch protection rules set in GitHub. These rules might restrict who can push directly to these branches, ensuring that changes are reviewed through pull requests.

Conclusion

Understanding Git branches and their management is essential for effective version control and collaboration. With the knowledge gained in this guide, you can confidently create, manage, and troubleshoot branches in both local and remote repositories. By recognizing the importance of both main and master branches, and the common issues associated with them, you can streamline your development workflow and ensure smoother collaboration. Happy coding!

Understanding Git Submodules: A Comprehensive Guide

Robiul Awal — Wed, 09 Oct 2024 20:56:51 +0000

Sure! Here’s the updated blog with a section specifically about removing a submodule on Windows.

Understanding Git Submodules: A Comprehensive Guide

Git is a powerful version control system that allows developers to manage and track changes in their code efficiently. Among its many features, Git submodules offer a unique way to handle project dependencies. This blog will delve into what Git submodules are, why you might need them, and how to use them effectively in your projects.

What Are Git Submodules?

In simple terms, a Git submodule is a repository nested inside another Git repository. This allows you to include and manage a separate project within your main project. Submodules are particularly useful when your project relies on external libraries or components that you want to keep as separate repositories.

Why Use Git Submodules?

Modularity: By using submodules, you can keep your codebase modular. Each component can evolve independently, making it easier to maintain and update.
Version Control: Submodules allow you to specify which commit of a submodule you want to use. This means that even if the submodule repository updates, your main project will remain stable and can be updated at your discretion.
Collaboration: When working in a team, submodules can help manage dependencies shared among multiple projects, ensuring everyone is on the same page regarding versions.

How to Use Git Submodules

Adding a Submodule

To add a submodule to your Git repository, navigate to your project directory and use the following command:

git submodule add <repository-url> <path>

For example:

git submodule add https://github.com/example/libfoo.git libs/libfoo

This command does two things: it clones the specified repository into the given path and creates a .gitmodules file that tracks the submodule.

Adding a Local Repository as a Submodule

You can also add a local repository as a submodule. This is useful when you have a project stored on your local machine that you want to include in another project. To do this, use the following command:

git submodule add <local-repo-path> <path>

For example:

git submodule add ../libfoo libs/libfoo

This command adds the local repository located at ../libfoo as a submodule in the libs/libfoo directory of your main project.

Cloning a Repository with Submodules

When you clone a repository that contains submodules, you need to initialize and update them. You can do this in one step by using:

git clone --recurse-submodules <repository-url>

If you’ve already cloned the repository, run:

git submodule update --init --recursive

This will ensure that all submodules are downloaded and set to the specified commit.

Viewing All Submodules

To see all submodules in your Git repository, you can use the following methods:

Check the .gitmodules File: This file contains information about all submodules. You can view it by running:

   cat .gitmodules

Using the Git Command: List all submodules directly with:

   git submodule

Check Submodule Status: To see the status of all submodules, including whether they are up to date, use:

   git submodule status

Updating Submodules

To update a submodule to the latest commit on its master branch, navigate to the submodule directory and run:

git checkout master
git pull

After pulling the latest changes, go back to your main project directory and commit the updated submodule reference:

git add <submodule-path>
git commit -m "Updated submodule"

Removing a Submodule

If you need to remove a submodule, follow these steps:

On Windows

Remove the Entry from .gitmodules:
- Open the .gitmodules file in a text editor.
- Delete the section corresponding to the submodule you want to remove.
Remove the Submodule's Entry in .git/config:
- Open the Git configuration file located at .git/config.
- Remove the section for the submodule.
Run the Git Command:
Open your command prompt (or Git Bash) and run:

   git rm --cached <submodule-path>

Delete the Submodule’s Directory: Use the following command to remove the directory:

   rmdir /s /q <submodule-path>

Alternatively, you can delete the directory using File Explorer.

Commit Your Changes: Finally, commit the changes:

   git commit -m "Removed submodule"

Best Practices for Using Git Submodules

Keep Submodules Updated: Regularly check for updates in your submodules to take advantage of improvements and bug fixes.
Document Submodule Usage: Clearly document the purpose of each submodule in your README or another suitable location to help team members understand their significance.
Use Specific Commits: Avoid using the latest commit in the submodule. Instead, reference a specific commit to ensure stability in your main project.
Regular Maintenance: Make it a habit to review and update submodules periodically, as outdated dependencies can lead to compatibility issues.

Conclusion

Git submodules can be a powerful tool for managing dependencies in your projects. By understanding how to effectively add, update, and manage submodules, you can keep your code organized and maintainable. Whether you’re working on personal projects or collaborating with a team, mastering Git submodules will enhance your workflow and improve project management. Happy coding!

Feel free to make any further adjustments!

Understanding and Implementing Custom User Profile Fields in WordPress

Robiul Awal — Mon, 18 Dec 2023 07:47:32 +0000

The provided code defines a class named WSEL_User_Fields in WordPress that facilitates the addition of custom fields to user profiles. These fields include "Membership number," "Join Date," and "Re Registration Date." Let's break down the code and understand how it works:

Class Initialization:

if ( ! class_exists( 'WSEL_User_Fields' ) ) :
    class WSEL_User_Fields {

This conditional check ensures that the class WSEL_User_Fields is defined only if it doesn't already exist.

Constructor:

public function __construct() {
    add_action( 'show_user_profile', array( $this, 'wsel_profile_fields' ), 999 );
    add_action( 'edit_user_profile', array( $this, 'wsel_profile_fields' ), 999 );

    add_action( 'personal_options_update', array( $this, 'wsel_save_profile_fields' ) );
    add_action( 'edit_user_profile_update', array( $this, 'wsel_save_profile_fields' ) );
}

The constructor sets up various WordPress actions to display and save the custom user profile fields. The show_user_profile and edit_user_profile actions are used to display the fields, while personal_options_update and edit_user_profile_update are used to save the field values.

Saving Profile Fields:

public function wsel_save_profile_fields( $user_id ) {
    // Checks for security nonce and user capability
    if ( ! isset( $_POST['_wpnonce'] ) || ! wp_verify_nonce( $_POST['_wpnonce'], 'update-user_' . $user_id ) ) {
        return;
    }

    if ( ! current_user_can( 'edit_user', $user_id ) ) {
        return;
    }

    // Update user meta with sanitized field values
    update_user_meta( $user_id, 'wsel_membership_number', sanitize_text_field( $_POST['wsel_membership_number'] ) );
    update_user_meta( $user_id, 'wsel_join_date', sanitize_text_field( $_POST['wsel_join_date'] ) );
    update_user_meta( $user_id, 'wsel_re_registration_date', sanitize_text_field( $_POST['wsel_re_registration_date'] ) );
}

This function handles the saving of custom field values when a user updates their profile. It checks for security nonce verification and user capabilities before updating the user meta with the sanitized values.

Displaying Profile Fields:

public function wsel_profile_fields( $user ) {
    // Retrieve custom field values
    $wsel_membership_number    = get_user_meta( $user->ID, 'wsel_membership_number', true );
    $wsel_join_date            = get_user_meta( $user->ID, 'wsel_join_date', true );
    $wsel_re_registration_date = get_user_meta( $user->ID, 'wsel_re_registration_date', true );
    ?>
    <!-- HTML markup to display the custom fields -->
    <h3>Additional Information</h3>
    <table class="form-table">
        <!-- Membership number field -->
        <tr>
            <th><label for="wsel_membership_number">Membership number</label></th>
            <td>
                <input type="text" name="wsel_membership_number" id="wsel_membership_number" value="<?php echo esc_attr( $wsel_membership_number ); ?>" class="regular-text" />
            </td>
        </tr>
        <!-- Join Date field -->
        <tr>
            <th><label for="wsel_join_date">Join Date</label></th>
            <td>
                <input type="text" name="wsel_join_date" id="wsel_join_date" value="<?php echo esc_attr( $wsel_join_date ); ?>" class="regular-text" />
            </td>
        </tr>
        <!-- Re Registration Date field -->
        <tr>
            <th><label for="wsel_re_registration_date">Re Registration Date</label></th>
            <td>
                <input type="text" name="wsel_re_registration_date" id="wsel_re_registration_date" value="<?php echo esc_attr( $wsel_re_registration_date ); ?>" class="regular-text" />
            </td>
        </tr>
    </table>
    <?php
}

This function generates the HTML markup for displaying the custom fields on the user profile page. It retrieves the stored values and populates the input fields accordingly.

Conclusion:

In summary, the provided code defines a WordPress class that adds custom fields to user profiles, allowing users to input and save additional information. The fields are displayed on the user profile page, and the entered data is stored securely in the user meta. This functionality can be useful for websites that require specific user details beyond the default WordPress profile fields.

how to create a custom setting tab in WooCommerce?

Robiul Awal — Mon, 18 Dec 2023 07:47:06 +0000

Creating a custom settings tab in WooCommerce involves a bit of PHP coding, as WooCommerce provides hooks and functions for extending its settings. Below is a basic outline of the steps you can follow to create a custom settings tab:

Step 1: Set up your WordPress plugin

Create a new directory for your plugin:
In your WordPress plugins directory (usually wp-content/plugins/), create a new directory for your plugin.
Create the main plugin file:
Inside your plugin directory, create a main PHP file (e.g., custom-woocommerce-tab.php).
Add plugin header:
In your main plugin file, start with the plugin header, including the plugin name, description, and other details.

   /*
   Plugin Name: Custom WooCommerce Tab
   Description: Add a custom settings tab in WooCommerce.
   Version: 1.0
   Author: Your Name
   */

   // Your code will go here

Step 2: Creating a class

/**
 * Custom WooCommerce Tab Class
 */
class Wooprint_Wc_Settings {


}

// Instantiate the class
new Wooprint_Wc_Settings();

In this class-based example:

The class is instantiated at the end, which automatically sets up the hooks and initializes the functionality.

This class encapsulates the functionality related to your custom WooCommerce tab, providing a more structured and organized way to handle your code.

Step 3: Add the custom settings tab

/**
 * Custom WooCommerce Tab Class
 */
class Wooprint_Wc_Settings {
        /**
         * string tab id;
         */
        public $tab_id;

        /**
         * Run all the actions and filter here.
         */
        public function __construct() {
            $this->tab_id = 'wooprint_tab';
            add_filter( 'woocommerce_settings_tabs_array', array( $this, 'wooprint_add_new_tab' ), 50 );
        }

                /**
         * Add a new tab to the WooCommerce settings tabs array
         *
         * @param array $tabs all tabs.
         * @return array
         */
        public function wooprint_add_new_tab( $tabs ) {
            $tabs[ $this->tab_id ] = __( 'Wooprint Tab', 'wooprint' );
            return $tabs;
        }

}

// Instantiate the class
new Wooprint_Wc_Settings();

Step 4: Add the custom section inside the custom settings tab

/**
 * Custom WooCommerce Tab Class
 */
class Wooprint_Wc_Settings {
        /**
         * string tab id;
         */
        public $tab_id;

        /**
         * Run all the actions and filter here.
         */
        public function __construct() {
            $this->tab_id = 'wooprint_tab';
            add_filter( 'woocommerce_settings_tabs_array', array( $this, 'wooprint_add_new_tab' ), 50 );
            add_action( 'woocommerce_sections_' . $this->tab_id, array( $this, 'wooprint_add_new_section' ) );
        }

        /**
         * Add a new tab to the WooCommerce settings tabs array
         *
         * @param array $tabs
         * @return array
         */
        public function add_wooprint_tab( $tabs ) {
            $tabs[ $this->tab_id ] = __( 'Wooprint Tab', 'wooprint' );
            return $tabs;
        }

        /**
         * Add new section inside tab.
         *
         * @return void
         */
        public function wooprint_add_new_section() {
            global $current_section;

            $sections      = array(
                ''                 => __( 'General Settings', 'wooprint' ),
                'invoice_settings' => __( 'Invoice Settings', 'wooprint' ),
            );
            $sections_keys = array_keys( $sections );

            echo '<ul class="subsubsub">';

            foreach ( $sections as $id => $label ) {
                $url = add_query_arg(
                    array(
                        'page'    => 'wc-settings',
                        'tab'     => $this->tab_id,
                        'section' => $id,
                    ),
                    admin_url( 'admin.php' )
                );

                $current = $current_section === $id ? 'current' : '';

                $separator = end( $sections_keys ) === $id ? '' : '|';

                echo '<li><a href="' . esc_url( $url ) . '" class="' . esc_html( $current ) . '">' . esc_attr( $label ) . '</a> ' . esc_attr( $separator ) . ' </li>';
            }

            echo '</ul><br class="clear" />';
        }

}

// Instantiate the class
new Wooprint_Wc_Settings();

Step final: Test your custom tab

Go to WooCommerce > Settings, and you should see your custom tab. You can then configure and save your custom settings.

Note: This is a basic example, and you may need to enhance it based on your specific needs. You can refer to the WooCommerce documentation for more details on available hooks and functions.

Mastering WordPress CLI: A Comprehensive Guide to Boost Your Productivity

Robiul Awal — Thu, 23 Nov 2023 19:27:19 +0000

WordPress CLI, or Command Line Interface, is a powerful tool that often remains underutilized by many WordPress users. If you're accustomed to managing your WordPress site through the familiar web interface, diving into the command line might seem daunting at first. However, the benefits are substantial, offering increased efficiency and control over your WordPress installation.

Understanding the Basics
Before we delve into the advanced features, let's start with the basics. The WordPress CLI allows you to perform various tasks from the command line, such as installing and updating plugins, managing users, and even updating the WordPress core itself. Familiarizing yourself with basic commands like wp plugin install and wp user list can significantly speed up your workflow.

Installing and Configuring WordPress via CLI
One of the standout features of WordPress CLI is the ability to install and configure a WordPress site directly from the command line. This is particularly handy for developers and system administrators who want to automate the setup process. Learn how to use commands like wp core download and wp config create to streamline your installation process.

Managing Themes and Plugins Efficiently
Are you tired of navigating through the WordPress dashboard to install and activate themes or plugins? With the WordPress CLI, you can perform these tasks with just a few simple commands. Discover how to use commands like wp theme install and wp plugin activate to manage your site's appearance and functionality seamlessly.

Advanced Tips and Tricks
Once you've mastered the basics, it's time to explore some advanced tips and tricks. Learn how to create custom commands, automate tasks with scripts, and integrate WordPress CLI into your development workflow. Unlock the full potential of the command line to save time and streamline your processes.

Troubleshooting and Best Practices
As with any powerful tool, understanding how to troubleshoot common issues is crucial. Explore common error messages and their solutions, and discover best practices for using WordPress CLI in different environments. From local development to production servers, ensure that you're making the most of this powerful tool while maintaining a secure and stable WordPress site.

Stay Updated and Join the Community
The world of WordPress CLI is continually evolving, with new features and improvements regularly being introduced. Stay informed about the latest updates and join the community of developers and enthusiasts who leverage the command line to enhance their WordPress experience.

In conclusion, WordPress CLI is a valuable tool that can significantly enhance your WordPress management experience. Whether you're a developer, site administrator, or power user, mastering the command line interface can boost your productivity and give you greater control over your WordPress site. Dive in, explore the possibilities, and elevate your WordPress game with the power of the CLI.

list of all wp cli command

As of my last knowledge update in January 2022, the list of WordPress CLI commands may have expanded or changed. It's always a good idea to check the official WP-CLI documentation for the most up-to-date information. Here's a list of common WP-CLI commands as of my last update:

Core Commands:
- wp core install
- wp core update
- wp core download
- wp core version
Plugin Commands:
- wp plugin install
- wp plugin activate
- wp plugin deactivate
- wp plugin update
- wp plugin list
Theme Commands:
- wp theme install
- wp theme activate
- wp theme deactivate
- wp theme update
- wp theme list
Post and Page Commands:
- wp post create
- wp post list
- wp post delete
- wp post update
User Commands:
- wp user create
- wp user list
- wp user delete
- wp user update
Comment Commands:
- wp comment list
- wp comment delete
- wp comment spam
Option Commands:
- wp option get
- wp option update
- wp option delete
Search and Replace:
- wp search-replace
Database Commands:
- wp db export
- wp db import
- wp db query
Server and Maintenance Commands:
- wp server
- wp maintenance-mode
Widget Commands:
- wp widget add
- wp widget update
- wp widget delete
Menu Commands:
- wp menu create
- wp menu list
- wp menu item add
- wp menu location assign
Post Type Commands:
- wp post-type list
- wp post-type create
- wp post-type update
Taxonomy Commands:
- wp taxonomy list
- wp taxonomy create
- wp taxonomy update
Export and Import Commands:
- wp export
- wp import
Rewrite Commands:
- wp rewrite flush
- wp rewrite structure
Site and Network Commands:
- wp site
- wp network

This is just a selection of WP-CLI commands. The WordPress CLI is extensive, and you can get a full list of commands by running wp --help. Additionally, you can get help for a specific command by running, for example, wp plugin install --help. Keep in mind that new commands and features may have been added since my last update, so referring to the official documentation is recommended.

How to add a custom CLI command?

To add a custom CLI command in WordPress using WP-CLI, you'll need to create a custom command file and register it. Here's a step-by-step guide:

Create a Custom Command File:
- Start by creating a PHP file for your custom command. This file will contain the code for your command. For example, create a file named custom-command.php.

Write Your Custom Command Code:

Open custom-command.php in a text editor and define your custom command. Below is a simple example:

<?php

if ( class_exists( 'WP_CLI_Command' ) ) {

    /**
     * Custom CLI command.
     */
    class Custom_Command extends WP_CLI_Command {

        /**
         * Display a custom message.
         *
         * ## EXAMPLES
         *
         *     wp custom command
         *
         * @when after_wp_load
         */
        public function command() {
            WP_CLI::success( 'Custom command executed!' );
        }
    }

    WP_CLI::add_command( 'custom', 'Custom_Command' );
}

This example creates a custom command named custom that, when executed, displays a success message.

Save the Custom Command File:
- Save the custom-command.php file.
Place the File in the WP-CLI Custom Commands Directory:
- Move the custom-command.php file to the wp-cli/commands/ directory within your WordPress installation. If the commands directory doesn't exist, create it.

   mv custom-command.php /path/to/your/wordpress/installation/wp-cli/commands/

Verify the Custom Command:
- Open a terminal, navigate to your WordPress installation, and run the custom command:

   wp custom command

You should see the success message you defined in your custom command code.

That's it! You've added a custom command to WP-CLI. You can extend this example to create more complex commands based on your specific needs. Remember to check the official WP-CLI documentation for more details and best practices when working with custom commands.

How to watch directory files and run CLI commands in the node.js environment

Certainly! The node-watch package is a simple and effective solution for watching files and directories in a Node.js environment. Here's an example of how you can use node-watch to watch a directory and execute a CLI command when changes occur:

Install the node-watch package:
```
npm install node-watch
```

Create a Watcher Script:

Create a JavaScript file, e.g., watcher.js, with the following content:

const watch = require('node-watch');
const { exec } = require('child_process');

const directoryToWatch = '/path/to/your/directory';

const runCommand = () => {
    // Replace the following command with your specific WP-CLI command
    exec('wp your custom command', (error, stdout, stderr) => {
        if (error) {
            console.error(`Error: ${error.message}`);
            return;
        }
        console.log(`Command Output: ${stdout}`);
        console.error(`Command Errors: ${stderr}`);
    });
};

console.log(`Watching directory: ${directoryToWatch}`);

watch(directoryToWatch, { recursive: true }, (evt, name) => {
    console.log(`${name} has been ${evt}`);
    runCommand();
});

Replace /path/to/your/directory with the actual path of the directory you want to watch, and update 'wp your custom command' with the specific WP-CLI command you want to run.

Run the Watcher Script:
```
node watcher.js
```

The script using node-watch will now watch the specified directory and execute the WP-CLI command whenever changes occur (file added, changed, or removed).

This example provides a basic setup, and you may need to adapt it according to your specific needs or add error handling based on your project requirements. Remember to handle errors and implement necessary optimizations if you plan to use this in a production environment.

More details about How to add various arguments on the custom command

Certainly! Let's create a more elaborate example with a custom command named greet that takes multiple arguments and options. In this example, the command will allow users to customize the greeting message, choose a language, and specify whether they want a formal or informal greeting.

Step 1: Register the Command

In your main plugin file or wherever you're registering your commands:

WP_CLI::add_command('greet', 'Greet_Command');

Step 2: Create the Custom Command Class

Create a new PHP file (e.g., greet-command.php) and define your custom command class:

class Greet_Command extends WP_CLI_Command {

    /**
     * Display a personalized greeting.
     *
     * ## OPTIONS
     *
     * <name>
     * : The name of the person to greet.
     *
     * [--message=<message>]
     * : A custom message to include in the greeting.
     *
     * [--language=<language>]
     * : The language of the greeting (e.g., English, Spanish).
     * ---
     * default: English
     * options:
     *   - English
     *   - Spanish
     * ---
     *
     * [--formal]
     * : Use a formal greeting.
     *
     * ## EXAMPLES
     *
     *     wp greet John
     *     wp greet --message="Hi there" --language=Spanish --formal Mary
     *
     * @param array $args
     * @param array $assoc_args
     */
    public function __invoke($args, $assoc_args) {
        $name = $args[0];

        $message = isset($assoc_args['message']) ? $assoc_args['message'] : 'Hello';
        $language = isset($assoc_args['language']) ? $assoc_args['language'] : 'English';
        $formal = isset($assoc_args['formal']);

        $greeting = $this->generateGreeting($message, $name, $language, $formal);

        WP_CLI::success($greeting);
    }

    /**
     * Generate a personalized greeting based on options.
     *
     * @param string $message
     * @param string $name
     * @param string $language
     * @param bool $formal
     *
     * @return string
     */
    private function generateGreeting($message, $name, $language, $formal) {
        $greetings = [
            'English' => $formal ? "Good day, $name." : "$message, $name!",
            'Spanish' => $formal ? "Buen día, $name." : "$message, $name.",
        ];

        return $greetings[$language];
    }
}

In this example:

The <name> option is a required argument for the greet command, representing the name of the person to greet.
The --message option allows users to provide a custom greeting message. If not provided, it defaults to "Hello."
The --language option lets users specify the language of the greeting. It has predefined options and defaults to English.
The --formal option, if present, indicates that a formal greeting should be used.
The generateGreeting method is a helper function that constructs the greeting based on the provided options.

Step 3: Run the Command

Run the command in the terminal:

wp greet John

This will output a default informal greeting in English. You can also use various options:

wp greet --message="Hi there" --language=Spanish --formal Mary

This will output a formal greeting in Spanish.

Feel free to customize the command and options based on your specific needs. This example demonstrates how to handle required arguments, optional options, default values, and how to incorporate logic in your command.