quick-cicd2
Advanced tools
The QUICK-CICD Generator is a powerful Node.js CLI tool that automatically generates Docker configurations, CI/CD pipelines, and deployment scripts for various project types.
Command to run:
npx quick-cicd
Developer Contact:
Before generating CI/CD configurations, you need to create your application. Here are the commands for creating different types of projects:
# Create new Vite + React project
npm create vite@latest my-react-app -- --template react
cd my-react-app
npm install
# Alternative with specific template
npm create vite@latest my-react-app -- --template react-ts # TypeScript
npm create vite@latest my-react-app -- --template react-swc # SWC compiler
# Using other package managers
yarn create vite my-react-app --template react
pnpm create vite my-react-app --template react
# Create new Next.js project
npx create-next-app@latest my-nextjs-app
cd my-nextjs-app
# With specific options
npx create-next-app@latest my-nextjs-app --typescript --tailwind --eslint --app
npx create-next-app@latest my-nextjs-app --javascript --src-dir --import-alias "@/*"
# Using other package managers
yarn create next-app my-nextjs-app
pnpm create next-app my-nextjs-app
# Initialize new Node.js project
mkdir my-node-backend
cd my-node-backend
npm init -y
# Install Express.js
npm install express cors helmet morgan dotenv
npm install -D nodemon
# Create basic Express server
mkdir src
echo 'const express = require("express");
const app = express();
const PORT = process.env.PORT || 3000;
app.use(express.json());
app.get("/", (req, res) => {
res.json({ message: "Hello from Node.js API!" });
});
app.listen(PORT, () => {
console.log(`Server running on port ${PORT}`);
});' > src/index.js
# Create NestJS project (alternative)
npm i -g @nestjs/cli
nest new my-nest-project
cd my-nest-project
# Create new Laravel project
composer create-project laravel/laravel my-laravel-app
cd my-laravel-app
# Alternative using Laravel installer
composer global require laravel/installer
laravel new my-laravel-app
cd my-laravel-app
# Generate application key
php artisan key:generate
# Create virtual environment
python -m venv django_env
source django_env/bin/activate # Linux/Mac
# django_env\Scripts\activate # Windows
# Install Django
pip install django
# Create Django project
django-admin startproject myproject .
cd myproject
# Create Django app
python manage.py startapp myapp
# Create requirements.txt
pip freeze > requirements.txt
# Create virtual environment
python -m venv fastapi_env
source fastapi_env/bin/activate # Linux/Mac
# fastapi_env\Scripts\activate # Windows
# Install FastAPI and dependencies
pip install fastapi uvicorn sqlalchemy pymysql
# Create basic FastAPI app
mkdir app
echo 'from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI(title="My FastAPI App")
@app.get("/")
async def root():
return {"message": "Hello from FastAPI!"}
@app.get("/health")
async def health_check():
return JSONResponse(content={"status": "healthy"})' > main.py
# Create requirements.txt
pip freeze > requirements.txt
# Create Python project directory
mkdir my-python-app
cd my-python-app
# Create virtual environment
python -m venv venv
source venv/bin/activate # Linux/Mac
# venv\Scripts\activate # Windows
# Install Flask for web server
pip install flask
# Create basic Flask app
echo 'from flask import Flask, jsonify
app = Flask(__name__)
@app.route("/")
def hello():
return jsonify({"message": "Hello from Python Flask!"})
if __name__ == "__main__":
app.run(host="0.0.0.0", port=5000)' > app.py
# Create requirements.txt
pip freeze > requirements.txt
The tool automatically checks these requirements when you run it:
When you run npx quick-cicd, you'll see:
✓ Checking system requirements...
Node.js v18.17.0 ✓, Git ✓, Docker ✓
# Install Node.js from nodejs.org or using Chocolatey
choco install nodejs git docker-desktop
# Verify installation
node --version
git --version
docker --version
# Install using Homebrew
brew install node git
brew install --cask docker
# Verify installation
node --version
git --version
docker --version
# Install Node.js
curl -fsSL https://deb.nodesource.com/setup_18.x | sudo -E bash -
sudo apt-get install -y nodejs git
# Install Docker
sudo apt-get update
sudo apt-get install docker.io docker-compose
# Verify installation
node --version
git --version
docker --version
# Must have these files in your project root:
├── package.json # Required - Contains Vite & React dependencies
├── vite.config.js # Vite configuration
├── src/ # Source code directory
│ ├── main.jsx # Entry point
│ └── App.jsx # Main component
└── index.html # HTML template
npm create vite@latest my-react-app -- --template react
cd my-react-app
npm install
vite in dependencies or devDependenciesreact in dependenciesreact-dom in dependenciesproject-root/
├── Dockerfile # Multi-stage build for React + Vite
├── docker-compose.yml # Container orchestration
├── ecosystem.config.js # PM2 process manager configuration
├── deploy.sh # Deployment automation script
├── .env.example # Environment variables template
├── package.json # Your existing file
├── vite.config.js # Your existing file
└── src/ # Your existing source code
├── main.jsx
└── App.jsx
import { defineConfig } from 'vite';
import react from '@vitejs/plugin-react';
export default defineConfig({
plugins: [react()],
server: {
host: '0.0.0.0',
port: 3000,
},
build: {
outDir: 'dist',
sourcemap: false,
},
});
# Must have these files in your project root:
├── package.json # Required - Contains Next.js dependencies
├── next.config.js # Next.js configuration (optional)
├── pages/ # Pages directory OR
├── app/ # App directory (Next.js 13+)
│ ├── layout.js # Root layout
│ └── page.js # Home page
└── public/ # Static assets
npx create-next-app@latest my-nextjs-app
cd my-nextjs-app
next in dependenciesreact in dependenciesreact-dom in dependenciesproject-root/
├── Dockerfile # Optimized for Next.js (build + runtime)
├── docker-compose.yml # Container with Next.js optimizations
├── ecosystem.config.js # PM2 configuration for Next.js
├── deploy.sh # Next.js specific deployment
├── .env.example # Next.js environment variables
├── package.json # Your existing file
├── next.config.js # Your existing file
├── pages/ # Your existing pages
└── public/ # Your existing static assets
/** @type {import('next').NextConfig} */
const nextConfig = {
output: 'standalone',
experimental: {
outputFileTracingRoot: path.join(__dirname, '../../'),
},
};
module.exports = nextConfig;
NODE_ENV=production
PORT=3000
NEXTAUTH_SECRET=your-secret-key
NEXTAUTH_URL=http://localhost:3000
# Must have these files in your project root:
├── package.json # Required - Contains Express/NestJS dependencies
├── src/ # Source code directory OR
├── index.js # Entry point OR
├── app.js # Main application file
└── routes/ # Routes directory (optional)
# Express.js
mkdir my-node-backend && cd my-node-backend
npm init -y
npm install express cors helmet morgan dotenv
# NestJS
npm i -g @nestjs/cli
nest new my-nest-project
express OR @nestjs/core in dependenciesproject-root/
├── Dockerfile # Backend-optimized container
├── docker-compose.yml # Multi-service (App + MySQL + Redis)
├── ecosystem.config.js # PM2 configuration for backend
├── deploy.sh # Backend deployment with database
├── .env.example # Database and service configurations
├── package.json # Your existing file
├── src/ # Your existing source code
│ ├── index.js
│ ├── routes/
│ └── controllers/
└── node_modules/ # Your existing dependencies
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
require('dotenv').config();
const app = express();
const PORT = process.env.PORT || 3000;
// Middleware
app.use(helmet());
app.use(cors());
app.use(morgan('combined'));
app.use(express.json());
// Routes
app.get('/', (req, res) => {
res.json({ message: 'Node.js API is running!' });
});
app.get('/health', (req, res) => {
res.json({ status: 'healthy', timestamp: new Date().toISOString() });
});
app.listen(PORT, () => {
console.log(`Server running on port ${PORT}`);
});
services:
app: # Your Node.js application
mysql: # MySQL 8.0 database
redis: # Redis cache
NODE_ENV=production
PORT=3000
DB_HOST=mysql
DB_PORT=3306
DB_USER=root
DB_PASSWORD=rootpassword
DB_NAME=your_database
REDIS_HOST=redis
REDIS_PORT=6379
JWT_SECRET=your-jwt-secret
# Must have these files in your project root:
├── composer.json # Required - Contains Laravel dependencies
├── artisan # Laravel CLI tool
├── app/ # Application code
│ ├── Http/
│ └── Models/
├── config/ # Configuration files
├── database/ # Database files
│ ├── migrations/
│ └── seeders/
├── routes/ # Route definitions
│ ├── web.php
│ └── api.php
└── storage/ # Storage directory
├── app/
├── framework/
└── logs/
composer create-project laravel/laravel my-laravel-app
cd my-laravel-app
php artisan key:generate
laravel/framework in composer.jsonproject-root/
├── Dockerfile # PHP-FPM with Nginx
├── docker-compose.yml # Laravel + MariaDB setup
├── deploy.sh # Laravel-specific deployment
├── .env.example # Laravel environment template
├── composer.json # Your existing file
├── artisan # Your existing Laravel CLI
├── app/ # Your existing application code
├── config/ # Your existing configuration
├── database/ # Your existing database files
├── routes/ # Your existing routes
├── storage/ # Your existing storage
└── vendor/ # Composer dependencies
services:
app: # Laravel application (PHP-FPM + Nginx)
mariadb: # MariaDB 10.6 database
APP_NAME=YourLaravelApp
APP_ENV=production
APP_KEY=base64:your-app-key
APP_DEBUG=false
APP_URL=http://localhost
DB_CONNECTION=mysql
DB_HOST=mariadb
DB_PORT=3306
DB_DATABASE=laravel_db
DB_USERNAME=laravel_user
DB_PASSWORD=laravel_password
# Recommended project structure (optional - will be created if missing):
├── manage.py # Django management script (indicates Django project)
├── requirements.txt # Python dependencies (optional)
├── myproject/ # Project directory
│ ├── __init__.py
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
└── myapp/ # Application directory (optional)
├── __init__.py
├── models.py
├── views.py
└── urls.py
# Create virtual environment
python -m venv django_env
source django_env/bin/activate # Linux/Mac
# django_env\Scripts\activate # Windows
# Install Django
pip install django
# Create project
django-admin startproject myproject .
python manage.py startapp myapp
pip freeze > requirements.txt
requirements.txt fileproject-root/
├── Dockerfile # Python Django container
├── docker-compose.yml # Django + MySQL + Nginx setup
├── nginx/
│ └── conf.d/
│ └── default.conf # Nginx configuration for Django
├── deploy.sh # Django deployment script
├── .env.example # Django environment variables
├── requirements.txt # Sample Python dependencies (generated if missing)
├── manage.py # Your existing Django management script
├── myproject/ # Your existing Django project
│ ├── settings.py
│ ├── urls.py
│ └── wsgi.py
└── static/ # Static files directory
services:
web: # Django application
nginx: # Nginx reverse proxy
mysql: # MySQL 8.0 database
Django>=4.2.0
mysqlclient>=2.1.0
gunicorn>=20.1.0
python-decouple>=3.6
Pillow>=9.5.0
DEBUG=False
SECRET_KEY=your-django-secret-key
DATABASE_URL=mysql://django_user:django_password@mysql:3306/django_db
ALLOWED_HOSTS=localhost,127.0.0.1
# Recommended project structure (optional):
├── main.py # FastAPI application entry point
├── requirements.txt # Python dependencies (optional)
├── app/ # Application directory (optional)
│ ├── __init__.py
│ ├── routers/
│ ├── models/
│ └── database.py
└── tests/ # Tests directory (optional)
# Create virtual environment
python -m venv fastapi_env
source fastapi_env/bin/activate # Linux/Mac
# Install FastAPI
pip install fastapi uvicorn sqlalchemy pymysql
pip freeze > requirements.txt
# Create basic structure
mkdir app
touch main.py app/__init__.py
requirements.txt fileproject-root/
├── Dockerfile # FastAPI optimized container
├── docker-compose.yml # FastAPI + MySQL setup
├── deploy.sh # FastAPI deployment script
├── .env.example # API environment variables
├── requirements.txt # FastAPI dependencies (generated if missing)
├── main.py # Your existing FastAPI app (or create new)
├── app/ # Your existing application code
│ ├── routers/
│ ├── models/
│ └── database.py
└── tests/ # Your existing tests
from fastapi import FastAPI
from fastapi.responses import JSONResponse
app = FastAPI(
title="My FastAPI App",
description="A FastAPI application with CI/CD",
version="1.0.0"
)
@app.get("/")
async def root():
return {"message": "Hello from FastAPI!"}
@app.get("/health")
async def health_check():
return JSONResponse(content={"status": "healthy"})
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
return {"item_id": item_id, "q": q}
services:
web: # FastAPI application
mysql: # MySQL 8.0 database
fastapi>=0.100.0
uvicorn[standard]>=0.22.0
sqlalchemy>=2.0.0
pymysql>=1.0.3
pydantic>=2.0.0
python-multipart>=0.0.6
DATABASE_URL=mysql+pymysql://fastapi_user:fastapi_password@mysql:3306/fastapi_db
SECRET_KEY=your-fastapi-secret-key
ALGORITHM=HS256
ACCESS_TOKEN_EXPIRE_MINUTES=30
# Minimal requirements (all files will be created if missing):
├── *.py # Any Python files (optional)
├── requirements.txt # Python dependencies (optional)
└── static/ # Static files directory (optional)
# Create project directory
mkdir my-python-app && cd my-python-app
# Create virtual environment
python -m venv venv
source venv/bin/activate # Linux/Mac
# Install Flask
pip install flask
pip freeze > requirements.txt
project-root/
├── Dockerfile # Python with Flask/WSGI container
├── docker-compose.yml # Python + Nginx setup
├── nginx/
│ └── conf.d/
│ └── default.conf # Nginx configuration for Python
├── deploy.sh # Python deployment script
├── .env.example # Basic environment variables
├── requirements.txt # Python web dependencies (generated)
├── app.py # Sample Flask application (generated)
├── wsgi.py # WSGI entry point (generated)
└── static/ # Static files directory
services:
web: # Python Flask application
nginx: # Nginx reverse proxy
from flask import Flask, jsonify, render_template_string
app = Flask(__name__)
@app.route('/')
def hello_world():
return render_template_string('''
<!DOCTYPE html>
<html>
<head><title>Python Flask App</title></head>
<body>
<h1>Hello from Python Flask!</h1>
<p>Your Flask application is running successfully.</p>
<a href="/api">Check API</a>
</body>
</html>
''')
@app.route('/api')
def api():
return jsonify({"message": "Hello from Python Flask API!"})
@app.route('/health')
def health_check():
return jsonify({"status": "healthy"})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000, debug=False)
from app import app
if __name__ == "__main__":
app.run()
Flask>=2.3.0
gunicorn>=20.1.0
python-dotenv>=1.0.0
Select from the supported project types and create your application using the commands provided above.
# For Node.js projects
npm run dev # or npm start
# For Python projects
python app.py # or python manage.py runserver
# For PHP Laravel
php artisan serve
# For Next.js
npm run dev
cd your-project-directory
npx quick-cicd
The tool will automatically check:
✓ Checking system requirements...
Node.js v18.17.0 ✓, Git ✓, Docker ✓
Choose from the interactive menu:
📦 Select your project type:
❯ ⚛️ React with Vite (Frontend SPA)
🔼 Next.js (Full-stack React Framework)
🟢 Node.js Backend (Express/NestJS API)
🐘 PHP Laravel (Backend Framework)
--- Python Projects ---
🐍 Python Django (Full-stack Python Framework with MySQL)
⚡ Python FastAPI (API Framework with MySQL)
🔹 Simple Python (Python file with Nginx)
The tool validates your project structure:
✓ Validating project configuration...
✓ Project configuration validated successfully
If CI/CD files exist, choose an action:
⚠️ Existing files found:
• Dockerfile (Docker container configuration)
• docker-compose.yml (Docker Compose orchestration)
How would you like to proceed?
❯ 🔄 Overwrite existing files
📁 Create with different names (.new extension)
❌ Cancel operation
Watch the progress:
✓ Generating CI/CD files...
Generating Dockerfile... (1/5)
Generating docker-compose.yml... (2/5)
Generating deploy.sh... (3/5)
Generating .env.example... (4/5)
Generating ecosystem.config.js... (5/5)
📁 Generated Files:
─────────────────────────────────────────────────
✓ Dockerfile (Docker container configuration)
✓ docker-compose.yml (Docker Compose orchestration)
✓ ecosystem.config.js (PM2 process manager config)
✓ deploy.sh (Deployment automation script)
✓ .env.example (Environment variables template)
Follow the completion guide:
🎉 SUCCESS!
Your CI/CD configuration has been generated successfully!
📝 Next steps:
──────────────────────────────────────────────────
1. Review and customize the generated files
2. Configure environment variables in .env.example
3. Set up your deployment server
4. Test locally with Docker: docker-compose up
5. Build your project: npm run build
# Start Docker service
sudo systemctl start docker # Linux
# Or start Docker Desktop on Windows/Mac
# Check Docker status
docker --version
docker-compose --version
# Add user to docker group
sudo usermod -aG docker $USER
# Logout and login again
Run npx quick-cicd to get started with automated CI/CD setup for your project!
FAQs
## 🚀 Overview
We found that quick-cicd2 demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Multiple high-impact npm maintainers confirm they have been targeted in the same social engineering campaign that compromised Axios.
Security News
Axios compromise traced to social engineering, showing how attacks on maintainers can bypass controls and expose the broader software supply chain.
Security News
Node.js has paused its bug bounty program after funding ended, removing payouts for vulnerability reports but keeping its security process unchanged.