stackloom-cli 1.0.0

package/src/commands/generate/ci-cd.js

@@ -0,0 +1,378 @@
+#!/usr/bin/env node
+
+/**
+ * CI/CD Pipeline Generators
+ */
+
+export function generateGitHubActions() {
+  return `name: CI/CD Pipeline
+
+on:
+  push:
+    branches: [ main, develop ]
+  pull_request:
+    branches: [ main ]
+
+env:
+  NODE_VERSION: '20'
+  MONGO_VERSION: '6.0'
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    services:
+      mongodb:
+        image: mongo:${MONGO_VERSION}
+        ports:
+          - 27017:27017
+        options: >-
+          --health-cmd "echo 'db.runCommand(\"ping\").ok' | mongosh localhost:27017/test --quiet"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+
+    strategy:
+      matrix:
+        node-version: [${'$'}{{ env.NODE_VERSION }}]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Use Node.js ${'$'}{{ matrix.node-version }}
+        uses: actions/setup-node@v4
+        with:
+          node-version: ${'$'}{{ matrix.node-version }}
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: |
+          cd backend && npm ci
+          cd ../frontend && npm ci
+
+      - name: Run backend tests
+        run: cd backend && npm test
+        env:
+          MONGODB_URI: mongodb://localhost:27017/test
+          NODE_ENV: test
+
+      - name: Run frontend tests
+        run: cd frontend && npm test -- --watchAll=false
+        env:
+          CI: true
+
+      - name: Run lint
+        run: |
+          cd backend && npm run lint
+          cd frontend && npm run lint
+
+      - name: Build frontend
+        run: cd frontend && npm run build
+
+  security:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Run security audit
+        run: npm audit --audit-level=moderate
+
+      - name: Run SAST
+        uses: shiftleft/scan-action@v2
+        with:
+          output: reports/
+
+      - name: Upload security reports
+        uses: actions/upload-artifact@v4
+        with:
+          name: security-reports
+          path: reports/
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [test, security]
+    if: github.ref == 'refs/heads/main'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${'$'}{{ secrets.DOCKERHUB_USERNAME }}
+          password: ${'$'}{{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push backend
+        uses: docker/build-push-action@v5
+        with:
+          context: ./backend
+          push: true
+          tags: ${'$'}{{ secrets.DOCKERHUB_USERNAME }}/app-backend:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+      - name: Build and push frontend
+        uses: docker/build-push-action@v5
+        with:
+          context: ./frontend
+          push: true
+          tags: ${'$'}{{ secrets.DOCKERHUB_USERNAME }}/app-frontend:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  deploy:
+    runs-on: ubuntu-latest
+    needs: build
+    if: github.ref == 'refs/heads/main'
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Deploy to production
+        uses: appleboy/ssh-action@v1
+        with:
+          host: ${'$'}{{ secrets.SSH_HOST }}
+          username: ${'$'}{{ secrets.SSH_USER }}
+          key: ${'$'}{{ secrets.SSH_KEY }}
+          script: |
+            cd /opt/app
+            docker-compose pull
+            docker-compose up -d
+            docker system prune -f
+`;
+}
+
+export function generateGitLabCI() {
+  return `stages:
+  - test
+  - security
+  - build
+  - deploy
+
+variables:
+  NODE_VERSION: "20"
+  MONGO_VERSION: "6.0"
+  DOCKER_DRIVER: overlay2
+
+services:
+  - mongo:${MONGO_VERSION}
+
+test:backend:
+  stage: test
+  image: node:${NODE_VERSION}
+  before_script:
+    - npm ci
+    - npm run test:ci
+  script:
+    - npm run test
+  artifacts:
+    reports:
+      junit: junit.xml
+    when: always
+
+test:frontend:
+  stage: test
+  image: node:${NODE_VERSION}
+  before_script:
+    - cd frontend
+    - npm ci
+  script:
+    - npm run test:ci
+  artifacts:
+    reports:
+      junit: junit.xml
+    when: always
+
+lint:
+  stage: test
+  image: node:${NODE_VERSION}
+  script:
+    - npm run lint
+  allow_failure: true
+
+sast:
+  stage: security
+  image: shiftleft/scan
+  script:
+    - scan --type --src . --out reports/
+  artifacts:
+    paths:
+      - reports/
+
+dependency_scan:
+  stage: security
+  image: node:${NODE_VERSION}
+  script:
+    - npm audit --audit-level=moderate
+  allow_failure: true
+
+build:frontend:
+  stage: build
+  image: node:${NODE_VERSION}
+  script:
+    - cd frontend
+    - npm ci
+    - npm run build
+  artifacts:
+    paths:
+      - frontend/dist/
+    expire_in: 1 week
+
+docker:build:
+  stage: build
+  image: docker:latest
+  services:
+    - docker:dind
+  script:
+    - docker build -t \$CI_REGISTRY_IMAGE/backend:\$CI_COMMIT_SHA ./backend
+    - docker build -t \$CI_REGISTRY_IMAGE/frontend:\$CI_COMMIT_SHA ./frontend
+    - docker push \$CI_REGISTRY_IMAGE/backend:\$CI_COMMIT_SHA
+    - docker push \$CI_REGISTRY_IMAGE/frontend:\$CI_COMMIT_SHA
+  only:
+    - main
+
+deploy:production:
+  stage: deploy
+  image: alpine:latest
+  before_script:
+    - apk add --no-cache openssh-client
+    - eval \$(ssh-agent -s)
+    - echo "\$SSH_PRIVATE_KEY" | tr -d '\\r' | ssh-add -
+    - mkdir -p ~/.ssh
+    - chmod 700 ~/.ssh
+  script:
+    - ssh -o StrictHostKeyChecking=no \$SSH_USER@\$SSH_HOST "cd /opt/app && docker-compose pull && docker-compose up -d"
+  only:
+    - main
+`;
+}
+
+export function generateJenkinsfile() {
+  return `pipeline {
+    agent any
+
+    environment {
+        NODE_VERSION = '20'
+        MONGO_VERSION = '6.0'
+        DOCKER_REGISTRY = credentials('docker-registry')
+    }
+
+    stages {
+        stage('Checkout') {
+            steps {
+                checkout scm
+            }
+        }
+
+        stage('Setup') {
+            steps {
+                sh '''
+                    nvm install \${NODE_VERSION}
+                    nvm use \${NODE_VERSION}
+                '''
+            }
+        }
+
+        stage('Install Dependencies') {
+            steps {
+                sh '''
+                    cd backend && npm ci
+                    cd ../frontend && npm ci
+                '''
+            }
+        }
+
+        stage('Test') {
+            parallel {
+                stage('Backend Tests') {
+                    steps {
+                        sh '''
+                            docker run -d --name mongo -p 27017:27017 mongo:\${MONGO_VERSION}
+                            sleep 5
+                            cd backend && MONGODB_URI=mongodb://localhost:27017/test npm test
+                            docker stop mongo && docker rm mongo
+                        '''
+                    }
+                    post {
+                        always {
+                            junit 'backend/test-results/*.xml'
+                        }
+                    }
+                }
+
+                stage('Frontend Tests') {
+                    steps {
+                        sh '''
+                            cd frontend && CI=true npm test -- --watchAll=false
+                        '''
+                    }
+                    post {
+                        always {
+                            junit 'frontend/test-results/*.xml'
+                        }
+                    }
+                }
+            }
+        }
+
+        stage('Security Scan') {
+            steps {
+                sh 'npm audit --audit-level=moderate'
+            }
+        }
+
+        stage('Build') {
+            steps {
+                sh '''
+                    cd frontend && npm run build
+                '''
+                archiveArtifacts artifacts: 'frontend/build/**/*', fingerprint: true
+            }
+        }
+
+        stage('Docker Build') {
+            when {
+                branch 'main'
+            }
+            steps {
+                sh '''
+                    docker build -t \${DOCKER_REGISTRY_USR}/app:latest .
+                    docker push \${DOCKER_REGISTRY_USR}/app:latest
+                '''
+            }
+        }
+
+        stage('Deploy') {
+            when {
+                branch 'main'
+            }
+            steps {
+                sshagent(['production-server']) {
+                    sh '''
+                        ssh -o StrictHostKeyChecking=no user@production-server \
+                            "cd /opt/app && docker-compose pull && docker-compose up -d"
+                    '''
+                }
+            }
+        }
+    }
+
+    post {
+        always {
+            cleanWs()
+        }
+        success {
+            slackSend color: 'good', message: 'Pipeline succeeded!'
+        }
+        failure {
+            slackSend color: 'danger', message: 'Pipeline failed!'
+        }
+    }
+}
+`;
+}

package/src/commands/generate/deploy-advanced.js

@@ -0,0 +1,253 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+
+export async function generateDockerCompose(env = 'development') {
+  const configs = {
+    development: `version: '3.8'
+
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=development
+      - MONGODB_URI=mongodb://mongo:27017/app
+    volumes:
+      - .:/app
+      - /app/node_modules
+    depends_on:
+      - mongo
+      - redis
+    networks:
+      - app-network
+
+  mongo:
+    image: mongo:6.0
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongo-data:/data/db
+    environment:
+      - MONGO_INITDB_ROOT_USERNAME=admin
+      - MONGO_INITDB_ROOT_PASSWORD=password
+    networks:
+      - app-network
+
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis-data:/data
+    networks:
+      - app-network
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+    depends_on:
+      - app
+    networks:
+      - app-network
+
+volumes:
+  mongo-data:
+  redis-data:
+
+networks:
+  app-network:
+    driver: bridge
+`,
+    production: `version: '3.8'
+
+services:
+  app:
+    build:
+      context: .
+      target: production
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+      - MONGODB_URI=mongodb://mongo:27017/app
+    depends_on:
+      - mongo
+    networks:
+      - app-network
+    deploy:
+      replicas: 3
+      restart_policy:
+        condition: on-failure
+        max_attempts: 3
+
+  mongo:
+    image: mongo:6.0
+    volumes:
+      - mongo-data:/data/db
+    environment:
+      - MONGO_INITDB_ROOT_USERNAME=${MONGO_USER}
+      - MONGO_INITDB_ROOT_PASSWORD=${MONGO_PASSWORD}
+    networks:
+      - app-network
+
+volumes:
+  mongo-data:
+
+networks:
+  app-network:
+    driver: overlay
+`
+  };
+  
+  return configs[env] || configs.development;
+}
+
+export async function generateKubernetes(namespace = 'default') {
+  return `apiVersion: v1
+kind: Namespace
+metadata:
+  name: ${namespace}
+---
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app-deployment
+  namespace: ${namespace}
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: node-app
+  template:
+    metadata:
+      labels:
+        app: node-app
+    spec:
+      containers:
+      - name: app
+        image: your-registry/node-app:latest
+        ports:
+        - containerPort: 3000
+        env:
+        - name: NODE_ENV
+          value: "production"
+        - name: MONGODB_URI
+          valueFrom:
+            secretKeyRef:
+              name: app-secrets
+              key: mongodb-uri
+        resources:
+          requests:
+            memory: "256Mi"
+            cpu: "250m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        readinessProbe:
+          httpGet:
+            path: /ready
+            port: 3000
+          initialDelaySeconds: 5
+          periodSeconds: 5
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: app-service
+  namespace: ${namespace}
+spec:
+  selector:
+    app: node-app
+  ports:
+  - port: 80
+    targetPort: 3000
+  type: LoadBalancer
+---
+apiVersion: v1
+kind: Secret
+metadata:
+  name: app-secrets
+  namespace: ${namespace}
+type: Opaque
+data:
+  # echo -n 'your-mongodb-uri' | base64
+  mongodb-uri: <base64-encoded-uri>
+`;
+}
+
+export async function generateNginxConfig(domain = 'example.com', ssl = false) {
+  if (ssl) {
+    return `server {
+    listen 80;
+    server_name ${domain};
+    return 301 https://$server_name$request_uri;
+}
+
+server {
+    listen 443 ssl http2;
+    server_name ${domain};
+
+    ssl_certificate /etc/letsencrypt/live/${domain}/fullchain.pem;
+    ssl_certificate_key /etc/letsencrypt/live/${domain}/privkey.pem;
+    ssl_protocols TLSv1.2 TLSv1.3;
+    ssl_ciphers HIGH:!aNULL:!MD5;
+
+    location / {
+        proxy_pass http://app:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    location /api/ {
+        proxy_pass http://app:3000/api/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+}`;
+  }
+  
+  return `server {
+    listen 80;
+    server_name ${domain};
+
+    location / {
+        proxy_pass http://localhost:3000;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection 'upgrade';
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_cache_bypass $http_upgrade;
+    }
+
+    location /api/ {
+        proxy_pass http://localhost:3000/api/;
+        proxy_http_version 1.1;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    }
+}`;
+}

package/src/commands/generate/deploy.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+
+import path from 'path';
+import fs from 'fs-extra';
+import chalk from 'chalk';
+import ora from 'ora';
+
+export default async function generateDeployCmd(options) {
+  const spinner = ora();
+  const projectRoot = process.cwd();
+
+  // Targets might be "all"
+  const targets = options.target === 'all'
+    ? ['docker', 'vercel', 'railway']
+    : [options.target];
+
+  for (const target of targets) {
+    switch (target) {
+      case 'docker': {
+        spinner.start('Generating Dockerfile...');
+        const dockerfile = `FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN pnpm install --frozen-lockfile
+COPY . .
+RUN pnpm build
+
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY package*.json ./
+RUN pnpm install --prod --frozen-lockfile
+EXPOSE 5000
+CMD ["node", "backend/server.js"]
+`;
+        await fs.writeFile(path.join(projectRoot, 'Dockerfile'), dockerfile);
+        spinner.succeed('Dockerfile created');
+
+        spinner.start('Generating docker-compose.yml...');
+        const dc = `version: '3.8'
+services:
+  api:
+    build: .
+    ports:
+      - "5000:5000"
+    env_file:
+      - .env
+`;
+        await fs.writeFile(path.join(projectRoot, 'docker-compose.yml'), dc);
+        spinner.succeed('docker-compose.yml created');
+        break;
+      }
+      case 'vercel': {
+        spinner.start('Generating vercel.json...');
+        const vercelJson = {
+          version: 2,
+          builds: [
+            { src: 'frontend/package.json', use: '@vercel/static-build', config: { distDir: 'dist' } },
+            { src: 'backend/package.json', use: '@vercel/node' },
+          ],
+          routes: [
+            { src: '/api/(.*)', dest: '/backend/server.js' },
+            { handle: 'filesystem' },
+            { src: '/(.*)', dest: '/frontend/index.html' },
+          ],
+        };
+        await fs.writeFile(path.join(projectRoot, 'vercel.json'), JSON.stringify(vercelJson, null, 2));
+        spinner.succeed('vercel.json created');
+        break;
+      }
+      case 'railway': {
+        spinner.start('Generating railway.yaml...');
+        const railwayYaml = `{
+  "build": {
+    "builder": "NIXPACKS",
+    "env": {
+      "NODE_VERSION": "20"
+    }
+  },
+  "deploy": {
+    "startCommand": "pnpm start",
+    "restartPolicy": {
+      "policy": "ON_FAILURE",
+      "delayMs": 5000
+    }
+  }
+}
+`;
+        await fs.writeFile(path.join(projectRoot, 'railway.yaml'), railwayYaml);
+        spinner.succeed('railway.yaml created');
+        break;
+      }
+      default:
+        console.log(chalk.yellow(`⚠  Unknown target: ${target}`));
+    }
+  }
+
+  console.log(chalk.green('✓  Deployment configuration complete.'));
+}