neex 0.6.99 → 0.7.2

package/README.md

@@ -1,3 +1,4 @@
+
 <div align="center">
  <a href="https://github.com/Neexjs">
 <picture>
@@ -6,9 +7,10 @@
 </picture>
 </a>
 
-# Neex v0.6.37
+# Neex v0.7.1
+
+### Neex - Modern Fullstack Framework Built on Express and Next.js. Fast to Start, Easy to Build, Ready to Deploy.
 
-### 🚀 Neex: The Modern Build System for Polyrepo-in-Monorepo Architecture
 
 [![NPM version](https://img.shields.io/npm/v/neex.svg?style=for-the-badge&labelColor=000000&color=0066FF&borderRadius=8)](https://www.npmjs.com/package/neex)
 [![Download Count](https://img.shields.io/npm/dt/neex.svg?style=for-the-badge&labelColor=000000&color=0066FF&borderRadius=8)](https://www.npmjs.com/package/neex)
@@ -16,475 +18,342 @@
 [![GitHub](https://img.shields.io/badge/GitHub-Neex-0066FF.svg?style=for-the-badge&logo=github&labelColor=000000&logoWidth=20&borderRadius=8)](https://github.com/Neexjs)
 </div>
 
-## 🎯 Overview
 
-next + express = neex 🌱
-
-Neex is a modern build system and script runner designed for **Polyrepo-in-Monorepo** architectures, but powerful enough for any project. It simplifies managing and running multiple scripts across your project, whether they are microservices, frontend applications, or build tasks. Neex offers robust features like parallel and sequential execution, live-reloading for development (`watch`), optimized server running (`servers`), and even basic process management (`pm2`-like commands), all aimed at making your development workflow more efficient, organized, and visually clear.
+## 🎯 Overview
 
-## ✨ Key Features
+**Neex = nextjs + express 🌱**
 
-- 🎨 **Colored Output** - Distinguish commands with unique colors
-- ⚡ **Dual Execution Modes** - Run commands in parallel (`px`) or sequence (`s`, `run`)
-- ⏱️ **Smart Timing** - Track execution time for each command
-- 🛑 **Error Control** - Stop on first error (perfect for CI/CD)
-- 🔢 **Parallel Control** - Limit concurrent processes with `--max-parallel`
-- 💻 **Clean Output** - Structured and readable command output
-- 🛡️ **Safe Shutdown** - Graceful process termination on interrupt
-- 🤫 **Flexible Display** - Control prefixes, timing, and output visibility
-- 🧰 **Node.js API** - Programmatic usage in your applications
 
-## 🚀 Installation
+**Neex: A Powerful Fusion of Next.js and Express for Fullstack Development**
 
-Install Neex globally to use it anywhere, or locally in your project.
+**Neex** is a modern and advanced fullstack framework that combines **Next.js** and **Express** to deliver an exceptional development experience. Designed for speed, simplicity, and scalability, Neex empowers developers to effortlessly build and deploy robust, high-performance applications.
 
-```bash
-# Global install
-npm install -g neex
-
-# Local install
-npm install --save-dev neex    # npm
-yarn add --dev neex          # yarn
-pnpm add --save-dev neex     # pnpm
-bun add --dev neex           # bun
-```
+## ✨ Why Choose Neex?
 
-When installed locally, you can run Neex commands using `npx neex ...` or by adding them to your `package.json` scripts.
+Unlock the full potential of your fullstack projects with Neex’s powerful features, tailored for modern web development:
 
-## 🖥️ Usage
+* 🏗️ **Fullstack Architecture**: Independent codebases for **frontend (Next.js)** and **backend (Express)** with isolated dependencies for maximum flexibility.
+* 🔄 **Monorepo Workflow**: Enjoy the simplicity of a single repository with clear separation between frontend and backend domains.
+* ⚡ **Zero Configuration**: Out-of-the-box setup for **TypeScript**, **Prisma**, and **environment variable management** for instant development readiness.
+* 🛠️ **Production-Ready**: Built-in best practices for performance, scalability, and reliability at an enterprise level.
+* 📦 **Isolated Dependencies**: Each part of the stack has its own `package.json` to ensure modular and scalable development.
+* 🧩 **Separation of Concerns**: Clearly divided frontend and backend logic leads to cleaner, more maintainable codebases.
+* 🔒 **Secure Environment Management**: Built-in support for `dotenv` to handle environment variables safely and efficiently.
+* 📊 **Database Integration**: Native support for **Prisma ORM** enables fast, type-safe, and efficient database development.
+* 🛠️ **Powerful CLI**: Intuitive CLI commands to simplify development, building, and deployment workflows.
 
-```bash
-# Global install
-npm i -g neex
-
-# Local install
-npm i -D neex    # npm
-yarn add -D neex # yarn
-pnpm add -D neex # pnpm
-bun add -D neex  # bun
-```
+With these features, **Neex** is the ideal choice for developers seeking a fullstack framework that’s **SEO-optimized, scalable, efficient, and developer-friendly**. Start building high-performance web applications today with Neex’s robust toolset and clean architecture.
 
-## 🖥️ Usage
 
-### Core Commands
 
-Neex provides several commands to manage and run your scripts:
-
-- **`px <commands...>`** (*default command*)
-  - Runs specified commands in **parallel** by default.
-  - Use the `-q` or `--sequential` flag to run them sequentially.
-  - Ideal for build steps, tests, or any tasks that can run concurrently.
-
-- **`run <commands...>`** (alias: `s`)
-  - Runs specified commands **sequentially**.
-  - Useful for tasks that depend on the completion of previous ones (e.g., build then deploy).
-
-- **`servers <commands...>`** (alias: `srv`)
-  - Optimized for running multiple development **servers** (e.g., backend API, frontend app) in parallel.
-  - Provides grouped and clear output for each server, making it easy to monitor logs.
-  - Detects and displays server ports and URLs.
-
-- **`watch <commands...>`** (alias: `w`)
-  - Runs commands and **watches for file changes** to automatically restart them (Nodemon-like functionality).
-  - Highly configurable with options for watched paths, ignored patterns, extensions, and restart delays.
-  - Perfect for development workflows where you need instant feedback on code changes.
-
-- **Process Management Commands**
-  - Neex provides built-in process management capabilities, similar to PM2, for long-running applications. These commands operate directly under `neex`:
-    - **`start <script_path_or_command> [--name <name>] [--watch] [-- <args...>]`**: Start a new process.
-    - **`stop <name_or_id>`**: Stop a running process.
-    - **`restart <name_or_id>`**: Restart a running process.
-    - **`delete <name_or_id>`**: Stop and delete a process from the list.
-    - **`list`** (aliases: `ls`, `status`): List all managed processes.
-    - **`logs [name_or_id] [--lines <number>] [--follow]`**: Display logs for a specific process or all if no ID is given.
-    - **`monit`**: Launch a monitoring interface for all managed processes.
-    - **`save`**: Save the current list of running processes.
-    - **`resurrect`**: Restart processes that were previously saved.
-    - **`startup`**: Generate a sample startup script (e.g., for systemd).
-
-### General Command Examples
+## 🚀 Quick Start
 
-```bash
-# Parallel execution (default behavior for px)
-neex px "npm run build:api" "npm run build:frontend" "npm run lint"
-# px is the command for parallel execution
-neex px "npm run test:unit" "npm run test:integration"
+### Create a New Neex Project – Step-by-Step
 
-# Sequential execution
-neex run "npm run clean" "npm run build" "npm run deploy"
-# Alias for sequential
-neex s "echo First" "echo Second" "echo Third"
 
-# Run 'px' commands sequentially using the -q flag
-neex px -q "npm run step1" "npm run step2"
-```
+1. **Run one of the creation commands**:
+   ```bash
+   npx neex init
+   # or
+   npx create-neex
+   ```
 
-### `servers` Command Examples
+2. **Enter your project name** (e.g., `my-awesome-project`).
 
-```bash
-# Start frontend and backend development servers
-neex servers "cd frontend && npm start" "cd backend && npm start"
+3. **Select your package manager**:
+   - npm
+   - yarn
+   - pnpm
+   - bun
 
-# Group output for better readability
-neex servers --group-output "npm run dev:service-a" "npm run dev:service-b"
-```
+4. **Wait for the project structure to be created** automatically.
 
-### `watch` Command Examples
+5. **Install dependencies**:
+   ```bash
+   cd my-project
+   npm install  # or yarn, pnpm install, bun install
+   ```
 
-```bash
-# Watch for changes in './src' and restart 'npm run build'
-neex watch "npm run build" -w ./src
+6. **Start development**:
+   ```bash
+   npm run dev  # or yarn dev, pnpm dev, bun dev
+   ```
 
-# Watch for .ts file changes in 'services/' and restart two commands, ignoring 'node_modules'
-neex watch "npm run start:service1" "npm run start:service2" -w services/ -e ts,tsx -i node_modules/**
+7. **Access your project**:
+   - client: `http://localhost:3000`
+   - server: `http://localhost:8000`
 
-# Clear console on restart and set a delay
-neex watch "node server.js" --clear --delay 1500
-```
+## 🖥️ CLI Commands
 
-### Process Management Command Examples
+Neex provides a powerful CLI with commands tailored for development, building, and production deployment.
 
-```bash
-# Start a Node.js app and give it a name
-neex start server.js --name my-app
+### Core Commands
 
-# Start an app and watch for file changes
-neex start api/index.js --name my-api --watch
+- **`neex init`**: Initializes a new Neex project using `create-neex`.
+- **`neex dev [file]`**: Starts a fast TypeScript development server with live-reloading.
+- **`neex build [source]`**: Compiles TypeScript projects for production.
+- **`neex start [file]`**: Starts a production-ready application with process management (PM2-like).
+- **`neex p <commands...>`** (aliases: `par`, `parallel`): Runs commands in parallel.
+- **`neex s <commands...>`** (aliases: `seq`, `sequential`): Runs commands sequentially.
+- **`neex dev:clean`**: Cleans development cache and temporary files.
+- **`neex dev:check`**: Validates TypeScript configuration.
+- **`neex dev:info`**: Displays development server information.
 
-# List all running processes managed by neex
-neex list
+### Command Examples
 
-# View logs for 'my-app'
-neex logs my-app
+#### Development (`dev` Command)
 
-# Stop 'my-api'
-neex stop my-api
+The `dev` command provides a fast, live-reloading development environment.
 
-# Restart 'my-app'
-neex restart my-app
+```bash
+# Start development server for a TypeScript file
+neex dev src/index.ts
 
-# Delete 'my-api' from neex management
-neex delete my-api
-```
+# Watch specific directories
+neex dev --watch src,public "npm run dev"
 
-### `dev` Command Examples
+# Ignore patterns
+neex dev --ignore "*.log,dist/**" "node server.js"
 
-The `dev` command is designed for development environments, providing automatic file watching and restart functionality. Here are various ways to use it:
+# Specify file extensions
+neex dev --ext ts,tsx,js "npm run dev"
 
-#### 1. Automatic Usage
+# Ultra-fast mode with 50ms delay
+neex dev --fast "npm run dev"
+```
 
-When no arguments are provided, neex dev will automatically:
+#### Building (`build` Command)
 
-- If `package.json` has a `"dev"` script:
-  ```bash
-  neex dev  # runs: npm run dev
-  ```
+Compile TypeScript projects for production.
 
-- If only a `"start"` script exists:
-  ```bash
-  neex dev  # runs: npm run start
-  ```
+```bash
+# Build project from src to dist
+neex build
 
-- If only a `"main"` field exists:
-  ```bash
-  neex dev  # runs: node main.js (for JavaScript)
-  neex dev  # runs: npx ts-node main.ts (for TypeScript)
-  ```
+# Build with source maps and watch mode
+neex build src --sourcemap --watch
 
-#### 2. Direct File Execution
+# Quick compilation
+neex compile src
+```
 
-Run JavaScript or TypeScript files directly:
+#### Production (`start` Command)
 
-```bash
-# JavaScript file
-neex dev app.js  # runs: node app.js
+Run production-ready applications with advanced process management.
 
-# TypeScript file
-neex dev server.ts  # runs: npx ts-node server.ts
 
-# ES modules
-neex dev index.mjs
 
-# CommonJS TypeScript
-neex dev main.cts
-```
 
-#### 3. Package Manager Scripts
 
-Run npm/yarn/pnpm scripts:
 
 ```bash
-# npm scripts
-neex dev "npm run dev"
-neex dev "npm run start"
-neex dev "npm run build"
-
-# yarn scripts
-neex dev "yarn dev"
-neex dev "yarn start"
-
-# pnpm scripts
-neex dev "pnpm dev"
-neex dev "pnpm start"
-```
-
-#### 4. System Commands
+# Start production server
+neex start dist/server.js
 
-Execute various system commands:
+# Start with multiple workers
+neex start dist/server.js --workers 4
 
-```bash
-neex dev "python app.py"
-neex dev "php server.php"
-neex dev "go run main.go"
-neex dev "cargo run"
-neex dev "dotnet run"
+# Enable health check endpoint
+neex start dist/server.js --health-port 3001
 ```
 
-#### 5. Configuration Options
 
-Customize the development experience with these options:
+Below is an example of `package.json` scripts for running two projects (frontend and backend) concurrently, along with ORM (Prisma) integration, tailored for a Neex project with a polyrepo-in-monorepo architecture. This example demonstrates how to use Neex commands to manage development, building, and production workflows efficiently.
 
-```bash
-# Watch specific directories
-neex dev --watch src --watch public "npm run dev"
+```json
+{
+  "scripts": {
+    "dev": "neex p dev:client dev:server",
+    "dev:client": "cd apps/client && bun run dev",
+    "dev:server": "cd apps/server && bun run dev",
+    "build": "neex s prisma:generate prisma:migrate build:client build:server",
+    "build:client": "cd apps/client && bun run build",
+    "build:server": "cd apps/server && bun run build",
+    "start": "neex p start:client start:server",
+    "start:client": "cd apps/client && bun run start",
+    "start:server": "cd apps/server && bun run start",
+    "prisma:generate": "cd apps/server && bunx prisma generate",
+    "prisma:migrate": "cd apps/server && bunx prisma db push"
+  }
+}
+```
 
-# Ignore certain files/directories
-neex dev --ignore "*.log" --ignore "temp/**" "node server.js"
+### Explanation of Scripts
 
-# Specify file extensions
-neex dev --ext js,ts,vue,jsx "npm run dev"
+- **`dev`**: Uses `neex p` to run the frontend (`dev:client`) and backend (`dev:server`) development servers in parallel, leveraging Neex's ability to manage concurrent processes with clear output.
+- **`dev:client`**: Runs the Next.js frontend development server in the `apps/client` directory using Bun.
+- **`dev:server`**: Runs the Express backend development server in the `apps/server` directory using Bun.
+- **`build`**: Uses `neex s` to sequentially execute Prisma-related tasks (`prisma:generate`, `prisma:migrate`) followed by building both the frontend (`build:client`) and backend (`build:server`) projects.
+- **`build:client`**: Builds the Next.js frontend in the `apps/client` directory.
+- **`build:server`**: Builds the Express backend in the `apps/server` directory.
+- **`start`**: Uses `neex p` to start both the frontend (`start:client`) and backend (`start:server`) in production mode concurrently, utilizing Neex's advanced process management for clustering and health checks.
+- **`start:client`**: Starts the Next.js frontend in production mode.
+- **`start:server`**: Starts the Express backend in production mode.
+- **`prisma:generate`**: Generates the Prisma client for the backend in `apps/server`.
+- **`prisma:migrate`**: Applies Prisma database migrations in `apps/server`.
 
-# Set restart delay
-neex dev --delay 2000 "npm run dev"
+### Running the Scripts
 
-# Clear console on restart
-neex dev --clear "node app.js"
+```bash
+npm run dev          # Starts frontend and backend development servers in parallel
+npm run build        # Sequentially generates Prisma client, applies migrations, and builds both projects
+npm run start        # Starts frontend and backend in production mode concurrently
+```
 
-# Minimal output
-neex dev --minimal "npm run dev"
+Below is an example of `package.json` scripts for running two projects (frontend and backend) concurrently, along with ORM (Prisma) integration, tailored for a Neex project. This example demonstrates how to use Neex commands to manage development, building, and production workflows efficiently.
 
-# Disable colors
-neex dev --no-color "npm run dev"
+```json
+{
+  "scripts": {
+    "dev": "neex p dev:client dev:server",
+    "dev:client": "cd apps/client && bun run dev",
+    "dev:server": "cd apps/server && bun run dev",
+    "build": "neex s prisma:generate prisma:migrate build:client build:server",
+    "build:client": "cd apps/client && bun run build",
+    "build:server": "cd apps/server && bun run build",
+    "start": "neex p start:client start:server",
+    "start:client": "cd apps/client && bun run start",
+    "start:server": "cd apps/server && bun run start",
+    "prisma:generate": "cd apps/server && bunx prisma generate",
+    "prisma:migrate": "cd apps/server && bunx prisma db push"
+  }
+}
+```
 
-# Disable timing display
-neex dev --no-timing "npm run dev"
 
-# Stop on first error
-neex dev --stop-on-error "npm run test"
-```
+#### Parallel and Sequential Execution
 
-#### 6. Framework-Specific Examples
+Run multiple scripts efficiently.
 
 ```bash
-# Express.js
-neex dev server.js
+# Parallel execution
+neex p "npm run build:frontend" "npm run build:backend"
 
-# Fastify
-neex dev --watch src "npm run dev"
+# Sequential execution
+neex s "npm run clean" "npm run build" "npm run deploy"
 
-# Nest.js
-neex dev --watch src --ext ts "npm run start:dev"
+# Parallel with sequential flag
+neex p -q "npm run step1" "npm run step2"
+```
 
-# Koa.js
-neex dev --watch app --ext js "node app.js"
+## 📂 Project Structure
 
-# Electron
-neex dev --watch src --ext js,html "npm run electron"
+Neex creates a polyrepo-in-monorepo structure for clear separation and scalability:
 
-# Webpack Dev Server
-neex dev --watch src --ext js,css,html "npm run dev"
+```
+my-project/
+├── .env                 # Root environment variables
+├── apps/
+│   ├── client/          # Next.js frontend project
+│   │   ├── src/
+│   │   │   ├── app/     # Next.js App Router
+│   │   │   └── ...
+│   │   ├── next.config.ts
+│   │   ├── package.json # Frontend dependencies
+│   │   └── tsconfig.json
+│   └── server/          # Express backend project
+│       ├── src/
+│       │   ├── server.ts # Express server entry
+│       │   └── ...
+│       ├── package.json # Backend dependencies
+│       └── tsconfig.json
+├── package.json         # Root orchestration
+└── README.md
 ```
 
-#### 7. Error Handling
+Each `apps/client` and `apps/server` directory is a fully independent project that can be extracted into its own repository if needed, while benefiting from a unified monorepo workflow.
 
-```bash
-# No command specified and no default script
-neex dev
-# Error: No command specified for 'neex dev' and no default script
+## ⚙️ Advanced Options
 
-# Non-existent file
-neex dev nonexistent.js
-# Warning: File "nonexistent.js" not found. Attempting to run as command.
-```
+### `neex init`
 
-### 📚 Examples
+```bash
+# Create in current directory
+npx create-neex@latest .
 
-### Parallel Execution
+# Create with specific name
+npx create-neex@latest my-project
 
-```bash
-# Parallel execution (default behavior for p)
-neex p "npm run build:api" "npm run build:frontend" "npm run lint"
-neex par "npm run test:unit" "npm run test:integration"
-neex parallel "npm run test:frontend" "npm run test:backend"
+# Enable debug mode
+npx create-neex@latest my-project --debug
 ```
 
-### Sequential Execution
+### `neex dev`
 
 ```bash
-# Sequential execution using s command
-neex s "npm run clean" "npm run build" "npm run deploy"
-neex seq "echo First" "echo Second" "echo Third"
-neex sequential "npm run step1" "npm run step2" "npm run step3"
-```
+# Custom restart delay
+neex dev --delay 2000 "npm run dev"
 
-### Parallel with Sequential Flag
+# Disable console clearing
+neex dev --no-clear "node app.js"
 
-```bash
-# Run parallel commands sequentially using the -q flag
-neex p -q "npm run step1" "npm run step2"
-neex par -q "npm run build" "npm run test"
-neex parallel -q "npm run lint" "npm run format"
+# Framework-specific example (Nest.js)
+neex dev --watch src --ext ts "npm run start:dev"
 ```
 
-### Advanced Options
+### `neex build`
 
 ```bash
-# With retry options
-neex p --retry 3 --retry-delay 1000 "npm run test"
+# Custom output directory
+neex build src --output build
 
-# With output control
-neex s --no-color --no-timing --no-output "npm run build"
+# Specify TypeScript target
+neex build src --target es2022
 
-# With parallel limits
-neex p --max-parallel 2 "npm run build:frontend" "npm run build:backend" "npm run build:api"
+# Analyze bundle size
+neex build src --analyze
 ```
 
-### Advanced Example
+### `neex start`
 
 ```bash
-# Run tests & build with max 2 parallel tasks, stop on error
-neex p -s -m 2 -t "npm test" "npm run build" "npm run lint"
-```
+# Custom port
+neex start dist/server.js --port 8080
 
-## 📦 Node.js API
-
-```javascript
-import { run } from 'neex';
-// or: const { run } = require('neex');
-
-async function main() {
-  try {
-    // Sequential execution
-    await run(['echo Step 1', 'echo Step 2'], {
-      parallel: false,
-      stopOnError: true,
-      color: true
-    });
-
-    // Parallel execution (max 2)
-    await run(['npm test', 'npm run build'], {
-      parallel: true,
-      maxParallel: 2,
-      stopOnError: true
-    });
-  } catch (error) {
-    console.error('Failed:', error);
-    process.exit(1);
-  }
-}
-```
+# Enable Node.js inspector
+neex start dist/server.js --inspect
 
-### API Options (`RunOptions`)
-
-When using Neex programmatically, you can pass an options object to the `run` function:
-
-```typescript
-export interface RunOptions {
-  // Run in parallel or sequentially
-  parallel: boolean;
-  // Maximum number of parallel processes (default: CPU count)
-  maxParallel?: number;
-  // Show command output (default: true)
-  printOutput: boolean;
-  // Color output (default: true)
-  color: boolean;
-  // Show timing information (default: true)
-  showTiming: boolean;
-  // Show command prefix (default: true)
-  prefix: boolean;
-  // Stop on error (default: false)
-  stopOnError: boolean;
-  // Use minimal output format (default: false)
-  minimalOutput: boolean;
-  // Group output by command (default: false, mainly for server mode)
-  groupOutput: boolean;
-  // Use server mode formatting (default: false)
-  isServerMode: boolean;
-  // Number of times to retry a failed command (default: 0)
-  retry?: number;
-  // Delay in milliseconds between retries (default: 1000)
-  retryDelay?: number;
-  // Callback to register a cleanup function, called on SIGINT/SIGTERM
-  registerCleanup?: (cleanupFn: () => void) => void;
-}
+# Set memory limit
+neex start dist/server.js --max-memory 1G
 ```
 
-## 🔄 CI/CD Integration
-
-```yaml
-# GitHub Actions example
-steps:
-  - name: Test & Build
-    run: neex s -s "npm test" "npm run build"
 
-  - name: Parallel Tasks
-    run: neex p -s -m 4 "npm run lint" "npm test" "npm run e2e"
-```
 
-## 💡 Real-world Scenarios & `package.json` Integration
 
-Neex shines when integrated into your `package.json` scripts.
+## 💡 Real-World Scenarios
 
-**Example `package.json` scripts:**
+Integrate Neex into your `package.json` for a seamless workflow:
 
 ```json
 {
   "scripts": {
-    "dev:frontend": "cd packages/frontend && npm run dev",
-    "dev:backend": "cd packages/api && npm run dev",
-    "dev": "neex servers \"npm run dev:frontend\" \"npm run dev:backend\" --group-output",
-
-    "build:ui": "cd packages/ui-library && npm run build",
-    "build:app": "cd packages/main-app && npm run build",
-    "build": "neex runx \"npm run build:ui\" \"npm run build:app\"",
-
-    "test": "neex runx -s \"npm run test:unit\" \"npm run test:e2e\"",
-    "test:unit": "jest",
-    "test:e2e": "playwright test",
-
-    "lint": "eslint .",
-    "format": "prettier --write .",
-    "check-all": "neex p \"npm run lint\" \"npm run format -- --check\" \"npm run test\"",
-
-    "start:prod": "neex pm2 start dist/server.js --name my-prod-app",
-    "watch:build": "neex watch \"npm run build:app\" -w packages/main-app/src -e ts,tsx"
+    "dev": "neex dev src/server.ts",
+    "build": "neex build",
+    "start": "neex start"
   }
 }
 ```
 
-**Running these scripts:**
+Run scripts with:
 
 ```bash
-# Start all development servers with grouped output
-npm run dev
-
-# Build UI library and main application in parallel
-npm run build
+npm run dev    # Start development server with live-reloading
+npm run build  # Compile TypeScript project for production
+npm run start  # Start production server
+```
 
-# Run linters, format check, and all tests in parallel
-npm run check-all
+This configuration provides a minimal yet effective setup for developing, building, and deploying your Neex project. The `dev` command runs a TypeScript development server, `build` compiles the project, and `start` launches the production application.
 
-# Start the production application using neex's pm2
-npm run start:prod
+## 📋 System Requirements
 
-# Watch for changes in the main app's src and rebuild it
-npm run watch:build
-```
+- **Node.js**: 20.0.0 or later
+- **OS**: macOS, Windows, or Linux
+- **Package Manager**: npm, yarn, pnpm, or bun
 
 ## 🤝 Contributing
 
-We welcome contributions! Check our [issues page](https://github.com/Neexjs).
+Contributions are welcome! Visit our [GitHub issues page](https://github.com/Neexjs) to get started.
 
 ## 📄 License
 
-MIT
+MIT License. See [LICENSE](https://github.com/neexjs/blob/main/LICENSE) for details.

package/dist/src/cli-init.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neex",
-  "version": "0.6.99",
+  "version": "0.7.2",
   "description": "The Modern Build System for Polyrepo-in-Monorepo Architecture",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -19,13 +19,22 @@
     "test:sequence": "node ./dist/src/cli.js run \"echo Step 1\" \"echo Step 2\" \"echo Step 3\""
   },
   "keywords": [
-    "npm",
-    "run",
-    "script",
-    "parallel",
-    "sequential",
-    "command",
-    "cli"
+    "fullstack-framework",
+    "nextjs",
+    "express",
+    "monorepo",
+    "polyrepo",
+    "typescript",
+    "prisma",
+    "cli",
+    "build-system",
+    "web-development",
+    "node",
+    "javascript",
+    "production-ready",
+    "dotenv",
+    "parallel-execution",
+    "sequential-execution"
   ],
   "author": "foshati",
   "license": "MIT",
@@ -51,10 +60,10 @@
     "typescript": "^4.9.3"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/Neexjs"
   }
-}
+}