@procoderx/copy-file 1.0.0 → 1.0.1

package/README.md

@@ -1,48 +1,48 @@
-# ProCoderX Copy CLI
+# @procoderx/pcx-copy
 
-A lightweight Node.js CLI utility for copying files from one location to another.
+> A lightweight Node.js CLI utility for copying files from one location to another.
 
-`pcx-copy` provides a simple command-line interface for copying files while demonstrating the fundamentals of building and publishing an npm-based Node.js CLI package.
+[![npm version](https://img.shields.io/npm/v/@procoderx/pcx-copy.svg)](https://www.npmjs.com/package/@procoderx/pcx-copy)
+
+[![npm downloads](https://img.shields.io/npm/dm/@procoderx/pcx-copy.svg)](https://www.npmjs.com/package/@procoderx/pcx-copy)
+
+[![License](https://img.shields.io/npm/l/@procoderx/pcx-copy.svg)](https://www.npmjs.com/package/@procoderx/pcx-copy)
 
 ---
 
 ## Features
 
-- Copy files from the command line
-- Supports relative and absolute file paths
-- Uses Node.js `fs/promises`
-- Supports binary files through `Buffer`
-- Provides CLI argument validation
-- Displays clear usage and error messages
-- Returns appropriate process exit codes
-- Exposes a custom npm CLI command
-- Supports global npm installation
-- Can be executed through `npx`
-- Separates CLI handling from file-copy logic
+- **File Copying** — Copy files directly from the terminal.
+- **Relative & Absolute Paths** — Supports both relative and absolute source and destination paths.
+- **Binary File Support** — Uses Node.js `Buffer` to handle binary file contents.
+- **Node.js CLI** — Provides a simple command-line interface through the `pcx-copy` command.
+- **Modern ES Modules** — Built using JavaScript ES Modules.
+- **CLI Validation** — Validates required source and destination arguments.
+- **Error Handling** — Provides clear usage and file-system error messages.
+- **Process Exit Codes** — Returns appropriate exit codes when operations fail.
+- **Global CLI Support** — Install the package globally and use the command from anywhere.
+- **Zero-Install Execution** — Run the package directly with `npx`.
 
 ---
 
-## Tech Stack
+## Quick Start
 
-- **Node.js**
-- **JavaScript**
-- **ES Modules**
-- **npm**
-- **Node.js `fs/promises`**
-- **Node.js `path`**
+Run the package directly with `npx`:
 
----
+```bash
+npx @procoderx/pcx-copy ./source.txt ./destination.txt
+```
 
-## Requirements
+Or install it globally:
 
-- Node.js `18+`
-- npm `9+`
+```bash
+npm install -g @procoderx/pcx-copy
+```
 
-Check your installed versions:
+Then use:
 
 ```bash
-node -v
-npm -v
+pcx-copy ./source.txt ./destination.txt
 ```
 
 ---
@@ -51,100 +51,79 @@ npm -v
 
 ### Global Installation
 
-Install the CLI globally with npm:
+Install the package globally:
 
 ```bash
-npm install -g pcx-copy
+npm install -g @procoderx/pcx-copy
 ```
 
 After installation, the `pcx-copy` command is available globally.
 
-Verify the installation:
+Verify the command:
 
 ```bash
 pcx-copy
 ```
 
-If no arguments are provided, the CLI displays its usage information:
+If the required arguments are missing, the CLI displays:
 
 ```text
 Usage: pcx-copy <source-file> <destination-file>
 ```
 
----
-
-## Using with npx
+### Local Installation
 
-The package can also be executed with `npx` without manually installing it globally:
+Install the package as a dependency in your project:
 
 ```bash
-npx pcx-copy <source-file> <destination-file>
+npm install @procoderx/pcx-copy
 ```
 
-Example:
-
-```bash
-npx pcx-copy ./money.png ./buffer.png
-```
-
-This is useful when you want to run the CLI without adding it as a global command.
-
----
-
-## Local Development
+### Using npx
 
-Clone the repository:
+The package can also be executed without installing it globally:
 
 ```bash
-git clone https://github.com/theprocoderx/pcx-copy.git
+npx @procoderx/pcx-copy ./source.txt ./destination.txt
 ```
 
-Navigate into the project:
+---
 
-```bash
-cd pcx-copy
-```
+## Usage
 
-Install the project dependencies:
+### Syntax
 
 ```bash
-npm install
+pcx-copy <source-file> <destination-file>
 ```
 
-Link the package locally:
+The command accepts:
 
-```bash
-npm link
-```
-
-After linking, the `pcx-copy` command becomes available in your terminal.
+| Argument             | Required | Description                                  |
+| -------------------- | -------- | -------------------------------------------- |
+| `<source-file>`      | Yes      | Path to the file that should be copied       |
+| `<destination-file>` | Yes      | Path where the copied file should be created |
 
 ---
 
-## Usage
+## Examples
 
-### Basic Syntax
-
-```bash
-pcx-copy <source-file> <destination-file>
-```
-
-### Example
+### 1. Copy a File in the Same Directory
 
 ```bash
 pcx-copy ./money.png ./buffer.png
 ```
 
-The command copies:
+This copies:
 
 ```text
-./money.png
+money.png
 ```
 
 to:
 
 ```text
-./buffer.png
+buffer.png
 ```
 
 Successful output:
@@ -155,131 +134,123 @@ Successfully copied "./money.png" to "./buffer.png"
 
 ---
 
-## Copying to Another Location
-
-The CLI supports relative and absolute destination paths.
-
-### Relative Path
+### 2. Copy to Another Directory
 
 ```bash
 pcx-copy ./money.png ./backup/money.png
 ```
 
-### Absolute Path
+The source file is copied to the `backup` directory.
+
+---
+
+### 3. Copy Using an Absolute Destination Path
 
 ```bash
 pcx-copy ./money.png /c/Users/user/Desktop/buffer.png
 ```
 
-The source and destination paths are resolved before the file operation is performed.
+This copies the file to the specified absolute destination path.
 
 ---
 
-## Supported Files
-
-The utility works with regular files, including binary files such as:
+### 4. Copy a Text File
 
-- Images
-- PDFs
-- ZIP files
-- Videos
-- Documents
-- Other binary files
+```bash
+pcx-copy ./source.txt ./backup/source.txt
+```
 
-The file contents are handled as a Node.js `Buffer`.
+The same command works with text files and other regular files.
 
 ---
 
 ## How It Works
 
-The CLI receives arguments from the terminal through `process.argv`.
-
-For example:
+The application separates the command-line interface from the file-copy logic.
 
-```bash
-pcx-copy ./money.png ./buffer.png
-```
-
-The arguments are read using:
-
-```js
-const [, , source, destination] = process.argv;
-```
-
-The values become:
-
-```text
-source      → ./money.png
-destination → ./buffer.png
-```
+1. The CLI receives the source and destination paths.
+2. The arguments are read using `process.argv`.
+3. The CLI validates the required arguments.
+4. The file-copy function resolves the paths.
+5. The source file is read asynchronously.
+6. The file contents are stored in a `Buffer`.
+7. The buffer is written to the destination file.
+8. The CLI reports the result to the terminal.
 
-The CLI then passes these values to the file-copy logic.
+The overall flow is:
 
 ```text
-Terminal
-   │
-   │ pcx-copy <source> <destination>
-   ↓
+Terminal Command
+       ↓
 process.argv
-   ↓
-CLI Argument Validation
-   ↓
+       ↓
+Argument Validation
+       ↓
 copyFile()
-   ↓
+       ↓
 readFile()
-   ↓
+       ↓
 Buffer
-   ↓
+       ↓
 writeFile()
-   ↓
+       ↓
 Destination File
 ```
 
 ---
 
-## File Copy Implementation
+## Project Architecture
 
-The core file operation uses Node.js `fs/promises`:
+```text
+pcx-copy/
 
-```js
-const content = await readFile(sourcePath);
+├── bin/
+│   └── pcx-copy.js       # CLI entry point
 
-await writeFile(destinationPath, content);
-```
+├── src/
+│   └── copyFile.js       # Core file-copy logic
 
-The process is asynchronous and uses promises, allowing the CLI to work with Node.js's asynchronous filesystem APIs.
+├── package.json           # npm package configuration
+├── README.md
+└── LICENSE
+```
 
----
+### `bin/pcx-copy.js`
 
-## CLI Entry Point
+Responsible for:
 
-The executable entry point is:
+- Starting the CLI application
+- Reading `process.argv`
+- Validating CLI arguments
+- Calling the file-copy function
+- Displaying CLI messages
+- Handling process exit codes
 
-```text
-bin/pcx-copy.js
-```
+### `src/copyFile.js`
 
-It starts with the Node.js shebang:
+Contains the core file-copy logic responsible for:
 
-```js
-#!/usr/bin/env node
-```
+- Resolving file paths
+- Reading the source file
+- Writing the destination file
+- Performing the copy operation
 
-The shebang allows the file to be executed directly as a command when npm links the package's `bin` entry.
+### `package.json`
 
-The CLI entry point is responsible for:
+Defines:
 
-- Reading command-line arguments
-- Validating arguments
-- Calling the copy operation
-- Displaying CLI messages
-- Handling process exit codes
+- npm package metadata
+- Package name
+- Version
+- ES Module configuration
+- CLI binary mapping
+- Package configuration
 
 ---
 
-## npm `bin` Configuration
+## npm CLI Configuration
 
-The executable command is registered in `package.json`:
+The package exposes the `pcx-copy` command through the `bin` field in `package.json`.
 
 ```json
 {
@@ -289,92 +260,44 @@ The executable command is registered in `package.json`:
 }
 ```
 
-This creates the relationship:
+This creates the following relationship:
 
 ```text
 pcx-copy
-   ↓
+    ↓
 bin/pcx-copy.js
-   ↓
+    ↓
 Node.js
 ```
 
-Therefore, users can run:
+The CLI entry file uses a Node.js shebang:
 
-```bash
-pcx-copy ./source.txt ./destination.txt
+```js
+#!/usr/bin/env node
 ```
 
-instead of:
-
-```bash
-node bin/pcx-copy.js ./source.txt ./destination.txt
-```
+This allows npm to execute the file as a command.
 
 ---
 
-## Project Structure
-
-```text
-pcx-copy/
-├── bin/
-│   └── pcx-copy.js       ← CLI entry point (JavaScript)
-├── src/
-│   └── copyFile.js       ← file-copy logic (JavaScript)
-├── package.json          ← npm configuration
-├── README.md             ← documentation
-├── LICENSE               ← MIT license
-├── .gitignore
-└── .npmignore
-```
+## File Copy Implementation
 
----
+The core operation uses Node.js `fs/promises`:
 
-## Architecture
+```js
+const content = await readFile(sourcePath);
 
-```text
-Terminal
-   │
-   │ CLI command
-   ↓
-bin/pcx-copy.js
-   │
-   ├── process.argv
-   ├── argument validation
-   └── CLI output
-   │
-   ↓
-src/copyFile.js
-   │
-   ├── path resolution
-   ├── readFile()
-   └── writeFile()
-   │
-   ↓
-Destination File
+await writeFile(destinationPath, content);
 ```
 
-The CLI layer and application layer have separate responsibilities.
-
-### `bin/pcx-copy.js`
-
-Responsible for:
-
-- CLI arguments
-- Input validation
-- CLI output
-- Process exit codes
-
-### `src/copyFile.js`
-
-Responsible for:
+The file contents are handled as a `Buffer`, allowing the utility to copy different types of files, including:
 
-- Resolving paths
-- Reading the source file
-- Writing the destination file
-- Performing the file-copy operation
-
-This separation keeps the package easier to maintain and test.
+- Images
+- PDFs
+- ZIP files
+- Videos
+- Documents
+- Other binary files
 
 ---
 
@@ -394,74 +317,62 @@ displays:
 Usage: pcx-copy <source-file> <destination-file>
 ```
 
-File-system errors are handled using `try...catch`:
+File-system errors are handled and reported to the terminal.
 
-```js
-try {
-  // Copy operation
-} catch (error) {
-  console.error(`Failed to copy file: ${error.message}`);
-  process.exit(1);
-}
-```
+Example:
 
-A successful operation exits normally.
+```text
+Failed to copy file: ENOENT: no such file or directory
+```
 
-A failed operation returns a non-zero process exit code.
+The process returns a non-zero exit code when the operation fails.
 
 ---
 
-## Development
+## Requirements
+
+- Node.js 18+
+- npm 9+
 
-Run the CLI directly during development:
+Check your installed versions:
 
 ```bash
-node bin/pcx-copy.js ./source.txt ./destination.txt
+node -v
+npm -v
 ```
 
-Or link the package locally:
+---
+
+## Development
+
+Clone the repository:
 
 ```bash
-npm link
+git clone https://github.com/theprocoderx/pcx-copy.git
 ```
 
-Then use:
+Navigate into the project:
 
 ```bash
-pcx-copy ./source.txt ./destination.txt
+cd pcx-copy
 ```
 
----
+Install dependencies:
 
-## Package Configuration
-
-The npm package uses the `bin` field to expose the CLI command.
+```bash
+npm install
+```
 
-Example:
+For local CLI development, link the package:
 
-```json
-{
-  "name": "pcx-copy",
-  "version": "1.0.0",
-  "type": "module",
-  "bin": {
-    "pcx-copy": "./bin/pcx-copy.js"
-  }
-}
+```bash
+npm link
 ```
 
-The important relationship is:
+The command can then be tested locally:
 
-```text
-npm package
-     ↓
-package.json
-     ↓
-bin
-     ↓
-pcx-copy command
-     ↓
-bin/pcx-copy.js
+```bash
+pcx-copy ./source.txt ./destination.txt
 ```
 
 ---
@@ -472,39 +383,33 @@ Possible future versions may include:
 
 - `--help` option
 - `--version` option
+- `--update` option
 - Directory copying
 - Recursive directory copying
 - Multiple source files
 - File-existence checks
 - Overwrite confirmation
 - Progress indicators
-- Better cross-platform path handling
-- Improved error codes
+- Improved cross-platform path handling
 - Automated tests
-- npm package versioning and release automation
+- Improved CLI error codes
 
 ---
 
-## Learning Objectives
-
-This project demonstrates the fundamentals of Node.js CLI development:
+## License
 
-- `process.argv`
-- Node.js `fs/promises`
-- `Buffer`
-- Node.js `path`
-- ES Modules
-- Shebangs
-- npm `bin` configuration
-- CLI argument validation
-- Process exit codes
-- npm package structure
-- Global CLI installation
-- `npx` execution
-- Separation of CLI and application logic
+This project is licensed under the **MIT License**.
 
 ---
 
-## License
+## Author
 
-This project is licensed under the **MIT License**.
+**ProCoderX** (Magan Singh)
+
+Building practical Node.js tools and developer-focused projects.
+
+- **Website:** [procoderx.com](https://procoderx.com)
+- **GitHub:** [@TheProCoderX](https://github.com/theprocoderx)
+- **LinkedIn:** [ProCoderX](https://www.linkedin.com/in/procoderx)
+- **npm:** [@procoderx](https://www.npmjs.com/~procoderx)
+- **Email:** [procoderxs@gmail.com](mailto:procoderxs@gmail.com)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@procoderx/copy-file",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "A lightweight Node.js CLI tool for copying files from one location to another.",
   "type": "module",
   "bin": {
-    "pcx-copy": "./bin/pcx-copy.js"
+    "pcx-copy-file": "./bin/pcx-copy.js"
   },
   "files": [
     "bin",