dockerme 1.0.0

package/README.md

@@ -0,0 +1,113 @@
+# Dockerize
+
+Automatically generate Dockerfiles by analyzing your codebase. This npm package detects your project type and generates an appropriate Dockerfile for you.
+
+## Installation
+
+```bash
+npm install
+```
+
+## Usage
+
+### Local Development
+
+After installing dependencies, you can run:
+
+```bash
+npm link
+dockerize
+```
+
+### As npx Package
+
+Once published to npm, you can use it directly with:
+
+```bash
+npx dockerize
+```
+
+## Features
+
+- 🔍 **Automatic Detection**: Analyzes your codebase to detect project type
+- 🐳 **Smart Dockerfiles**: Generates optimized Dockerfiles for various frameworks
+- 📦 **Multi-language Support**: Supports Node.js, Python, Java, Go, Rust, Ruby, PHP, and more
+- ⚙️ **Framework-aware**: Detects specific frameworks like React, Next.js, Django, Flask, FastAPI, etc.
+
+## Supported Project Types
+
+### Node.js
+- **React/Vite**: Multi-stage build with nginx
+- **Next.js**: Optimized Next.js production build
+- **Backend**: Express, Fastify, Koa, etc.
+- **Generic Node.js**: Standard Node.js applications
+
+### Python
+- **Django**: Includes migrations and static files
+- **Flask**: Uses Gunicorn for production
+- **FastAPI**: Uses Uvicorn server
+- **Generic Python**: Standard Python applications
+
+### Java
+- **Maven**: Multi-stage build with Maven
+- **Gradle**: Multi-stage build with Gradle
+
+### Other Languages
+- **Go**: Multi-stage build with Go
+- **Rust**: Multi-stage build with Cargo
+- **Ruby**: Rails applications
+- **PHP**: Apache with Composer
+
+## Options
+
+```bash
+dockerize [options]
+
+Options:
+  -V, --version          Show version number
+  -o, --output <file>    Output Dockerfile path (default: "Dockerfile")
+  -f, --force            Overwrite existing Dockerfile
+  -h, --help             Display help for command
+```
+
+## Examples
+
+Generate a Dockerfile in the current directory:
+```bash
+dockerize
+```
+
+Generate a Dockerfile with a custom name:
+```bash
+dockerize -o Dockerfile.prod
+```
+
+Overwrite an existing Dockerfile:
+```bash
+dockerize --force
+```
+
+## How It Works
+
+1. **Analysis**: Scans your project directory for configuration files (package.json, requirements.txt, pom.xml, etc.)
+2. **Detection**: Identifies the project type and framework based on detected files
+3. **Generation**: Creates an optimized Dockerfile template for your specific project type
+
+## Publishing to npm
+
+To publish this package to npm:
+
+```bash
+npm login
+npm publish
+```
+
+After publishing, users can install and use it globally or via npx:
+
+```bash
+npx dockerize
+```
+
+## License
+
+MIT

package/bin/dockerize.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { program } = require('commander');
+const chalk = require('chalk');
+const { analyzeCodebase, generateDockerfile } = require('../lib/analyzer');
+
+program
+  .name('dockerize')
+  .description('Automatically generate Dockerfiles by analyzing your codebase')
+  .version('1.0.0')
+  .option('-o, --output <file>', 'Output Dockerfile path', 'Dockerfile')
+  .option('-f, --force', 'Overwrite existing Dockerfile', false)
+  .parse(process.argv);
+
+const options = program.opts();
+const projectRoot = process.cwd();
+
+async function main() {
+  try {
+    console.log(chalk.blue('🔍 Analyzing codebase...'));
+    
+    const analysis = analyzeCodebase(projectRoot);
+    
+    console.log(chalk.green(`✓ Detected project type: ${chalk.bold(analysis.projectType)}`));
+    if (analysis.details) {
+      console.log(chalk.gray(`  ${analysis.details}`));
+    }
+    
+    const dockerfileContent = generateDockerfile(analysis);
+    
+    const outputPath = path.join(projectRoot, options.output);
+    
+    // Check if file exists
+    if (fs.existsSync(outputPath) && !options.force) {
+      console.log(chalk.red(`✗ Dockerfile already exists at ${options.output}`));
+      console.log(chalk.yellow('  Use --force to overwrite'));
+      process.exit(1);
+    }
+    
+    fs.writeFileSync(outputPath, dockerfileContent);
+    console.log(chalk.green(`✓ Dockerfile generated successfully at ${options.output}`));
+    
+  } catch (error) {
+    console.error(chalk.red('✗ Error:'), error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/lib/analyzer.js

@@ -0,0 +1,636 @@
+const fs = require('fs');
+const path = require('path');
+
+function detectProjectType(projectRoot) {
+  const files = fs.readdirSync(projectRoot);
+  
+  // Check for package.json (Node.js)
+  if (files.includes('package.json')) {
+    const packageJson = JSON.parse(fs.readFileSync(path.join(projectRoot, 'package.json'), 'utf8'));
+    const scripts = packageJson.scripts || {};
+    
+    // Check for React/Vite
+    if (files.includes('vite.config.js') || files.includes('vite.config.ts') || 
+        files.includes('vite.config.mjs')) {
+      return { type: 'node-react-vite', packageJson };
+    }
+    
+    // Check for Next.js
+    if (files.includes('next.config.js') || files.includes('next.config.ts') ||
+        packageJson.dependencies?.next || packageJson.devDependencies?.next) {
+      return { type: 'node-nextjs', packageJson };
+    }
+    
+    // Check for Express/Fastify/etc
+    if (packageJson.dependencies?.express || packageJson.dependencies?.fastify ||
+        packageJson.dependencies?.koa || scripts.start || scripts.dev) {
+      return { type: 'node-backend', packageJson };
+    }
+    
+    return { type: 'node', packageJson };
+  }
+  
+  // Check for requirements.txt or setup.py (Python)
+  if (files.includes('requirements.txt') || files.includes('setup.py') ||
+      files.includes('pyproject.toml') || files.includes('Pipfile')) {
+    let pythonVersion = '3.11';
+    
+    // Try to detect Python version from runtime.txt or .python-version
+    if (files.includes('runtime.txt')) {
+      const runtime = fs.readFileSync(path.join(projectRoot, 'runtime.txt'), 'utf8').trim();
+      const match = runtime.match(/python-(\d+\.\d+)/);
+      if (match) pythonVersion = match[1];
+    }
+    
+    // Check for Django
+    if (files.includes('manage.py')) {
+      return { type: 'python-django', pythonVersion };
+    }
+    
+    // Check for Flask
+    if (files.includes('app.py') || files.includes('application.py')) {
+      const content = fs.readFileSync(path.join(projectRoot, files.includes('app.py') ? 'app.py' : 'application.py'), 'utf8');
+      if (content.includes('Flask') || content.includes('from flask')) {
+        return { type: 'python-flask', pythonVersion };
+      }
+    }
+    
+    // Check for FastAPI
+    if (files.includes('main.py')) {
+      const content = fs.readFileSync(path.join(projectRoot, 'main.py'), 'utf8');
+      if (content.includes('FastAPI') || content.includes('from fastapi')) {
+        return { type: 'python-fastapi', pythonVersion };
+      }
+    }
+    
+    return { type: 'python', pythonVersion };
+  }
+  
+  // Check for pom.xml (Java Maven)
+  if (files.includes('pom.xml')) {
+    return { type: 'java-maven' };
+  }
+  
+  // Check for build.gradle (Java Gradle)
+  if (files.includes('build.gradle') || files.includes('build.gradle.kts')) {
+    return { type: 'java-gradle' };
+  }
+  
+  // Check for go.mod (Go)
+  if (files.includes('go.mod')) {
+    return { type: 'go' };
+  }
+  
+  // Check for Cargo.toml (Rust)
+  if (files.includes('Cargo.toml')) {
+    return { type: 'rust' };
+  }
+  
+  // Check for Gemfile (Ruby)
+  if (files.includes('Gemfile')) {
+    return { type: 'ruby' };
+  }
+  
+  // Check for composer.json (PHP)
+  if (files.includes('composer.json')) {
+    return { type: 'php' };
+  }
+  
+  // Default to generic
+  return { type: 'generic' };
+}
+
+function analyzeCodebase(projectRoot) {
+  const detection = detectProjectType(projectRoot);
+  
+  let details = '';
+  
+  switch (detection.type) {
+    case 'node-react-vite':
+      details = 'React application with Vite';
+      break;
+    case 'node-nextjs':
+      details = 'Next.js application';
+      break;
+    case 'node-backend':
+      details = 'Node.js backend application';
+      break;
+    case 'node':
+      details = 'Node.js application';
+      break;
+    case 'python-django':
+      details = 'Django web framework';
+      break;
+    case 'python-flask':
+      details = 'Flask web framework';
+      break;
+    case 'python-fastapi':
+      details = 'FastAPI web framework';
+      break;
+    case 'python':
+      details = 'Python application';
+      break;
+    case 'java-maven':
+      details = 'Java Maven project';
+      break;
+    case 'java-gradle':
+      details = 'Java Gradle project';
+      break;
+    case 'go':
+      details = 'Go application';
+      break;
+    case 'rust':
+      details = 'Rust application';
+      break;
+    case 'ruby':
+      details = 'Ruby application';
+      break;
+    case 'php':
+      details = 'PHP application';
+      break;
+    default:
+      details = 'Generic application';
+  }
+  
+  return {
+    projectType: detection.type,
+    details,
+    ...detection
+  };
+}
+
+function generateDockerfile(analysis) {
+  const templates = {
+    'node-react-vite': generateNodeReactViteDockerfile,
+    'node-nextjs': generateNextJSDockerfile,
+    'node-backend': generateNodeBackendDockerfile,
+    'node': generateNodeDockerfile,
+    'python-django': generatePythonDjangoDockerfile,
+    'python-flask': generatePythonFlaskDockerfile,
+    'python-fastapi': generatePythonFastAPIDockerfile,
+    'python': generatePythonDockerfile,
+    'java-maven': generateJavaMavenDockerfile,
+    'java-gradle': generateJavaGradleDockerfile,
+    'go': generateGoDockerfile,
+    'rust': generateRustDockerfile,
+    'ruby': generateRubyDockerfile,
+    'php': generatePHPDockerfile,
+    'generic': generateGenericDockerfile
+  };
+  
+  const generator = templates[analysis.projectType] || generateGenericDockerfile;
+  return generator(analysis);
+}
+
+// Node.js templates
+function generateNodeDockerfile(analysis) {
+  const nodeVersion = analysis.packageJson?.engines?.node?.replace(/[^0-9.]/g, '') || '18';
+  const hasStartScript = analysis.packageJson?.scripts?.start;
+  
+  return `FROM node:${nodeVersion}-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy application code
+COPY . .
+
+${hasStartScript ? '# Expose port (adjust if needed)\nEXPOSE 3000\n\n# Start application\nCMD ["npm", "start"]' : '# Add your start command here\n# CMD ["node", "index.js"]'}
+`;
+}
+
+function generateNodeReactViteDockerfile(analysis) {
+  const nodeVersion = analysis.packageJson?.engines?.node?.replace(/[^0-9.]/g, '') || '18';
+  
+  return `# Build stage
+FROM node:${nodeVersion}-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci
+
+# Copy application code
+COPY . .
+
+# Build application
+RUN npm run build
+
+# Production stage
+FROM nginx:alpine
+
+# Copy built files from builder
+COPY --from=builder /app/dist /usr/share/nginx/html
+
+# Copy nginx configuration (optional)
+# COPY nginx.conf /etc/nginx/conf.d/default.conf
+
+EXPOSE 80
+
+CMD ["nginx", "-g", "daemon off;"]
+`;
+}
+
+function generateNextJSDockerfile(analysis) {
+  const nodeVersion = analysis.packageJson?.engines?.node?.replace(/[^0-9.]/g, '') || '18';
+  
+  return `FROM node:${nodeVersion}-alpine AS base
+
+# Install dependencies only when needed
+FROM base AS deps
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci
+
+# Rebuild the source code only when needed
+FROM base AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+
+# Build Next.js
+RUN npm run build
+
+# Production image
+FROM base AS runner
+WORKDIR /app
+
+ENV NODE_ENV production
+
+RUN addgroup --system --gid 1001 nodejs
+RUN adduser --system --uid 1001 nextjs
+
+COPY --from=builder /app/public ./public
+COPY --from=builder --chown=nextjs:nodejs /app/.next ./.next
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/package.json ./package.json
+
+USER nextjs
+
+EXPOSE 3000
+
+ENV PORT 3000
+
+CMD ["npm", "start"]
+`;
+}
+
+function generateNodeBackendDockerfile(analysis) {
+  const nodeVersion = analysis.packageJson?.engines?.node?.replace(/[^0-9.]/g, '') || '18';
+  const port = analysis.packageJson?.port || 3000;
+  
+  return `FROM node:${nodeVersion}-alpine
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+
+# Install dependencies
+RUN npm ci --only=production
+
+# Copy application code
+COPY . .
+
+EXPOSE ${port}
+
+# Start application
+CMD ["npm", "start"]
+`;
+}
+
+// Python templates
+function generatePythonDockerfile(analysis) {
+  const pythonVersion = analysis.pythonVersion || '3.11';
+  
+  return `FROM python:${pythonVersion}-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    gcc \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose port (adjust if needed)
+EXPOSE 8000
+
+# Add your start command here
+# CMD ["python", "app.py"]
+`;
+}
+
+function generatePythonDjangoDockerfile(analysis) {
+  const pythonVersion = analysis.pythonVersion || '3.11';
+  
+  return `FROM python:${pythonVersion}-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    gcc \\
+    postgresql-client \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Collect static files
+RUN python manage.py collectstatic --noinput || true
+
+EXPOSE 8000
+
+# Run migrations and start server
+CMD python manage.py migrate && python manage.py runserver 0.0.0.0:8000
+`;
+}
+
+function generatePythonFlaskDockerfile(analysis) {
+  const pythonVersion = analysis.pythonVersion || '3.11';
+  
+  return `FROM python:${pythonVersion}-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    gcc \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+EXPOSE 5000
+
+ENV FLASK_APP=app.py
+ENV FLASK_ENV=production
+
+CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"]
+`;
+}
+
+function generatePythonFastAPIDockerfile(analysis) {
+  const pythonVersion = analysis.pythonVersion || '3.11';
+  
+  return `FROM python:${pythonVersion}-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \\
+    gcc \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements file
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+`;
+}
+
+// Java templates
+function generateJavaMavenDockerfile(analysis) {
+  return `FROM maven:3.9-eclipse-temurin-17 AS builder
+
+WORKDIR /app
+
+# Copy pom.xml and download dependencies
+COPY pom.xml .
+RUN mvn dependency:go-offline
+
+# Copy source code and build
+COPY src ./src
+RUN mvn clean package -DskipTests
+
+# Runtime stage
+FROM eclipse-temurin:17-jre-alpine
+
+WORKDIR /app
+
+# Copy built JAR
+COPY --from=builder /app/target/*.jar app.jar
+
+EXPOSE 8080
+
+ENTRYPOINT ["java", "-jar", "app.jar"]
+`;
+}
+
+function generateJavaGradleDockerfile(analysis) {
+  return `FROM gradle:7.6-jdk17 AS builder
+
+WORKDIR /app
+
+# Copy build files
+COPY build.gradle* settings.gradle* ./
+COPY gradle ./gradle
+
+# Download dependencies
+RUN gradle dependencies --no-daemon || true
+
+# Copy source and build
+COPY src ./src
+RUN gradle build --no-daemon -x test
+
+# Runtime stage
+FROM eclipse-temurin:17-jre-alpine
+
+WORKDIR /app
+
+# Copy built JAR
+COPY --from=builder /app/build/libs/*.jar app.jar
+
+EXPOSE 8080
+
+ENTRYPOINT ["java", "-jar", "app.jar"]
+`;
+}
+
+// Go template
+function generateGoDockerfile(analysis) {
+  return `FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+# Copy go mod files
+COPY go.mod go.sum ./
+
+# Download dependencies
+RUN go mod download
+
+# Copy source code
+COPY . .
+
+# Build application
+RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o app .
+
+# Runtime stage
+FROM alpine:latest
+
+RUN apk --no-cache add ca-certificates
+
+WORKDIR /root/
+
+COPY --from=builder /app/app .
+
+EXPOSE 8080
+
+CMD ["./app"]
+`;
+}
+
+// Rust template
+function generateRustDockerfile(analysis) {
+  return `FROM rust:1.75-alpine AS builder
+
+WORKDIR /app
+
+# Copy Cargo files
+COPY Cargo.toml Cargo.lock ./
+
+# Copy source code
+COPY src ./src
+
+# Build application
+RUN cargo build --release
+
+# Runtime stage
+FROM alpine:latest
+
+RUN apk --no-cache add ca-certificates libgcc
+
+WORKDIR /root/
+
+COPY --from=builder /app/target/release/* /root/app
+
+EXPOSE 8080
+
+CMD ["./app"]
+`;
+}
+
+// Ruby template
+function generateRubyDockerfile(analysis) {
+  return `FROM ruby:3.2-alpine
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apk add --no-cache build-base
+
+# Copy Gemfile
+COPY Gemfile Gemfile.lock ./
+
+# Install dependencies
+RUN bundle install
+
+# Copy application code
+COPY . .
+
+EXPOSE 3000
+
+CMD ["bundle", "exec", "rails", "server", "-b", "0.0.0.0"]
+`;
+}
+
+// PHP template
+function generatePHPDockerfile(analysis) {
+  return `FROM php:8.2-apache
+
+WORKDIR /var/www/html
+
+# Install system dependencies and PHP extensions
+RUN apt-get update && apt-get install -y \\
+    libzip-dev \\
+    unzip \\
+    && docker-php-ext-install zip pdo pdo_mysql \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Composer
+COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
+
+# Copy composer files
+COPY composer.json composer.lock ./
+
+# Install dependencies
+RUN composer install --no-dev --optimize-autoloader
+
+# Copy application code
+COPY . .
+
+# Set permissions
+RUN chown -R www-data:www-data /var/www/html
+
+EXPOSE 80
+
+CMD ["apache2-foreground"]
+`;
+}
+
+// Generic template
+function generateGenericDockerfile(analysis) {
+  return `# Generic Dockerfile
+# Please customize this based on your application needs
+
+FROM alpine:latest
+
+WORKDIR /app
+
+# Copy application files
+COPY . .
+
+# Add your build and run commands here
+# Example:
+# RUN apk add --no-cache <your-dependencies>
+# CMD ["./your-app"]
+
+EXPOSE 8080
+
+CMD ["echo", "Please customize this Dockerfile for your application"]
+`;
+}
+
+module.exports = {
+  analyzeCodebase,
+  generateDockerfile
+};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "dockerme",
+  "version": "1.0.0",
+  "description": "Automatically generate Dockerfiles by analyzing your codebase",
+  "main": "index.js",
+  "bin": {
+    "dockerize": "./bin/dockerize.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "docker",
+    "dockerfile",
+    "codebase",
+    "analysis",
+    "automation"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "chalk": "^4.1.2"
+  }
+}