@turboops/cli 1.0.91-dev.1467 → 1.0.91

package/dist/index.js

@@ -194,7 +194,7 @@ function getPackageName() {
 }
 
 // src/services/config.ts
-var BUILD_ENV = true ? "dev" : void 0;
+var BUILD_ENV = true ? "prod" : void 0;
 var API_URLS = {
   local: "http://localhost:3000",
   dev: "https://api.dev.turbo-ops.de",
@@ -739,12 +739,11 @@ var apiClient = {
   /**
    * Trigger a deployment (Project Token endpoint for CI/CD)
    */
-  async deploy(stageId, imageTag, composeFile) {
-    const body = {
-      stage: stageId
-    };
+  async deploy(stageId, imageTag, composeFile, envExamples) {
+    const body = { stage: stageId };
     if (imageTag) body.imageTag = imageTag;
     if (composeFile) body.composeFile = composeFile;
+    if (envExamples) body.envExamples = envExamples;
     return this.request("POST", "/project/deployment/deploy", body);
   },
   /**
@@ -790,7 +789,7 @@ var apiClient = {
       if (Date.now() - startTime > timeout) {
         throw new Error(`Deployment timeout after ${timeout / 1e3} seconds`);
       }
-      await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
+      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
     }
   }
 };
@@ -913,7 +912,7 @@ var authService = {
           success: false
         };
       }
-      await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
+      await new Promise((resolve5) => setTimeout(resolve5, pollInterval));
     }
     return { error: "Zeit\xFCberschreitung bei der Anmeldung", success: false };
   },
@@ -1327,8 +1326,8 @@ function getStatusColor(status) {
 }
 
 // src/commands/init.ts
-import { readFileSync as readFileSync2, existsSync as existsSync3, statSync } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { resolve as resolve2 } from "path";
 import chalk5 from "chalk";
 import { Command as Command3 } from "commander";
 import prompts2 from "prompts";
@@ -1429,7 +1428,7 @@ var aiToolsService = {
       text: `${config.name} arbeitet...`,
       color: "cyan"
     }).start();
-    return new Promise((resolve4) => {
+    return new Promise((resolve5) => {
       if (verbose) {
         spinner.stop();
         console.log(chalk4.dim("[DEBUG] Spawning child process..."));
@@ -1550,7 +1549,7 @@ var aiToolsService = {
           spinner.fail(`${config.name} fehlgeschlagen (Exit Code: ${code})`);
         }
         logger.newline();
-        resolve4(code === 0);
+        resolve5(code === 0);
       });
       child.on("error", (err) => {
         if (verbose) {
@@ -1559,7 +1558,7 @@ var aiToolsService = {
         spinner.fail(
           `Fehler beim Ausf\xFChren von ${config.name}: ${err.message}`
         );
-        resolve4(false);
+        resolve5(false);
       });
     });
   }
@@ -1588,6 +1587,262 @@ function formatToolAction(toolName, input) {
   }
 }
 
+// src/utils/ai-prompts.ts
+var DOCKER_SETUP_PROMPT = `Analysiere dieses Projekt und erstelle ein Docker-Setup f\xFCr TurboOps Production Deployment.
+
+=== TURBOOPS ANFORDERUNGEN ===
+- docker-compose.yml MUSS auf Root-Ebene liegen
+- ALLE Abh\xE4ngigkeiten m\xFCssen enthalten sein (DB, Redis, etc.) - production-ready!
+- Images m\xFCssen immutable sein (keine Volume-Mounts f\xFCr Code)
+- Datenbank-Volumes f\xFCr Persistenz sind erlaubt (named volumes)
+- Environment-Variablen via \${VARIABLE} Syntax (werden zur Laufzeit injiziert)
+
+=== ZU ERSTELLENDE DATEIEN ===
+
+1. docker-compose.yml (Root-Ebene) - Datenbanken + Application Services
+   WICHTIG: Keine Environment-Variablen f\xFCr Application Services!
+   - Environment-Variablen f\xFCr api/app werden von TurboOps zur Deployment-Zeit injiziert
+   - Datenbanken bekommen ihre Konfiguration (Credentials kommen von TurboOps)
+\`\`\`yaml
+services:
+  # === DATENBANKEN ===
+  mongo:
+    image: mongo:7
+    volumes:
+      - mongo_data:/data/db
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+
+  redis:
+    image: redis:7-alpine
+    volumes:
+      - redis_data:/data
+    healthcheck:
+      test: ["CMD", "redis-cli", "ping"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+
+  # === APPLICATION SERVICES (keine environment - kommt von TurboOps!) ===
+  # WICHTIG: image: muss gesetzt sein f\xFCr docker compose push!
+  api:
+    build:
+      context: .
+      dockerfile: ./projects/api/Dockerfile  # oder ./api/Dockerfile
+    image: \${IMAGE_NAME}/api:\${IMAGE_TAG:-latest}
+    expose:
+      - "3000"
+    depends_on:
+      mongo:
+        condition: service_healthy
+      redis:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+    restart: unless-stopped
+
+  app:
+    build:
+      context: .
+      dockerfile: ./projects/app/Dockerfile  # oder ./app/Dockerfile
+    image: \${IMAGE_NAME}/app:\${IMAGE_TAG:-latest}
+    expose:
+      - "3000"
+    depends_on:
+      api:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    restart: unless-stopped
+
+volumes:
+  mongo_data:
+  redis_data:
+\`\`\`
+
+2. Dockerfile f\xFCr jeden Service (im jeweiligen Ordner)
+   KRITISCH: IMMER --ignore-scripts bei npm ci verwenden!
+\`\`\`dockerfile
+# Stage 1: Dependencies
+FROM node:22-alpine AS deps
+WORKDIR /app
+COPY package*.json ./
+# KRITISCH: --ignore-scripts verhindert husky/prepare Fehler in Docker!
+RUN npm ci --ignore-scripts
+
+# Stage 2: Builder
+FROM node:22-alpine AS builder
+WORKDIR /app
+COPY --from=deps /app/node_modules ./node_modules
+COPY . .
+RUN npm run build
+
+# Stage 3: Runner (Production)
+FROM node:22-alpine AS runner
+WORKDIR /app
+ENV NODE_ENV=production
+# Non-root user f\xFCr Sicherheit
+RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
+COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
+COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
+COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
+
+# Writable directories for runtime files (TUS uploads, temp processing)
+RUN mkdir -p /app/uploads/tus /app/temp && chown -R nodejs:nodejs /app/uploads /app/temp
+
+USER nodejs
+EXPOSE 3000
+CMD ["node", "dist/main.js"]
+\`\`\`
+
+3. .dockerignore (Root-Ebene)
+\`\`\`
+node_modules
+.git
+.env*
+*.log
+dist
+.nuxt
+.output
+coverage
+\`\`\`
+
+=== WICHTIGE REGELN F\xDCR TURBOOPS ===
+- KRITISCH: IMMER \`npm ci --ignore-scripts\` verwenden (verhindert husky/prepare Fehler!)
+- KRITISCH: KEINE \`ports:\` \u2192 Verwende \`expose:\` (nur im Docker-Netzwerk sichtbar)
+- KRITISCH: KEINE \`environment:\` f\xFCr Application Services (api, app) \u2192 Env-Variablen werden von TurboOps zur Deployment-Zeit injiziert
+- Datenbank-Services (mongo, redis, etc.) OHNE environment - Credentials kommen von TurboOps
+- Ein Reverse-Proxy (Traefik) routet externe Anfragen
+- Pr\xFCfe die tats\xE4chliche Projektstruktur (projects/, packages/, apps/, oder flach)
+- Passe Dockerfile-Pfade entsprechend an
+- NestJS: CMD ["node", "dist/main.js"]
+- Nuxt: CMD ["node", ".output/server/index.mjs"]
+- Nutze wget statt curl f\xFCr healthchecks (curl nicht in alpine)
+- Named volumes f\xFCr Datenbank-Persistenz (mongo_data, redis_data, etc.)
+- Keine Code-Volume-Mounts (Code ist im Image)
+- depends_on mit condition: service_healthy f\xFCr korrekten Start-Order
+- Erkenne ben\xF6tigte Services aus package.json (mongoose \u2192 mongo, ioredis \u2192 redis, etc.)
+
+Erstelle alle notwendigen Dateien basierend auf der erkannten Projektstruktur und Abh\xE4ngigkeiten.`;
+function buildPipelineIntegrationPrompt(pipelineType, projectSlug, pipelinePath, templateContent) {
+  const pipelineTypeName = pipelineType === "gitlab" ? "GitLab CI" : "GitHub Actions";
+  if (templateContent) {
+    return `WICHTIG: Integriere das TurboOps Deployment-Template EXAKT wie vorgegeben in die bestehende ${pipelineTypeName} Pipeline.
+
+Bestehende Pipeline-Datei: ${pipelinePath}
+
+=== TURBOOPS TEMPLATE (NICHT VER\xC4NDERN!) ===
+\`\`\`yaml
+${templateContent}
+\`\`\`
+=== ENDE TEMPLATE ===
+
+STRIKTE REGELN:
+1. Das TurboOps Template MUSS EXAKT so \xFCbernommen werden wie oben angegeben
+2. KEINE \xC4nderungen an:
+   - Variables (IMAGE_NAME, DOCKER_TLS_CERTDIR)
+   - Job-Namen (build, deploy-dev, deploy-test, deploy-prod)
+   - Script-Befehlen (turbo deploy, docker build, etc.)
+   - Branch-Rules (die sind korrekt f\xFCr die konfigurierten Stages)
+   - needs/dependencies zwischen Jobs
+3. NUR erlaubte \xC4nderungen:
+   - Stages der bestehenden Pipeline VOR den TurboOps-Stages einf\xFCgen
+   - Bestehende Jobs der Pipeline BEHALTEN (z.B. lint, test)
+   - TurboOps "build" Job muss von bestehenden Build-Jobs abh\xE4ngen (needs)
+
+MERGE-STRATEGIE:
+- Bestehende stages: [lint, test, build] + TurboOps stages: [build, deploy-dev, deploy-test, deploy-prod]
+- Ergebnis: stages: [lint, test, build, turboops-build, deploy-dev, deploy-test, deploy-prod]
+- Der TurboOps "build" Job sollte in "turboops-build" umbenannt werden falls es bereits einen "build" Job gibt
+- turboops-build needs: [build] (vom bestehenden build Job)
+
+Modifiziere die Datei "${pipelinePath}" entsprechend.`;
+  }
+  return `Erstelle eine neue ${pipelineTypeName} Pipeline f\xFCr TurboOps Deployment.
+
+Projekt-Slug: ${projectSlug}
+Pipeline-Datei: ${pipelinePath}
+
+WICHTIG - Branch-zu-Stage-Zuordnung (STRIKT EINHALTEN!):
+- dev Stage \u2192 deployed NUR wenn Branch == "dev"
+- test Stage \u2192 deployed NUR wenn Branch == "test"
+- prod Stage \u2192 deployed NUR wenn Branch == "main"
+
+PIPELINE-STRUKTUR:
+
+1. BUILD-JOB (l\xE4uft NUR auf dem default branch z.B. dev):
+   stages: [build, deploy]
+
+   build:
+     image: docker:24-dind
+     stage: build
+     services: [docker:24-dind]
+     before_script:
+       - docker login -u ${projectSlug} -p \${TURBOOPS_TOKEN} ${configService.getRegistryUrl()}
+     script:
+       - docker compose -f docker-compose.yml build
+       - docker compose -f docker-compose.yml push
+     only:
+       - dev  # L\xE4uft nur auf dem default branch
+
+2. DEPLOY-JOBS (jeder NUR auf seinem Branch!):
+   WICHTIG: KEIN --image Flag n\xF6tig! Die CLI erkennt CI_COMMIT_SHA automatisch!
+
+   deploy-dev:
+     image: node:22-alpine
+     stage: deploy
+     before_script:
+       - npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
+       - turbo config set token \${TURBOOPS_TOKEN}
+     script:
+       - turbo deploy dev --wait  # CLI erkennt Image automatisch via CI_COMMIT_SHA
+     only:
+       - dev  # NUR auf dev Branch!
+
+   deploy-test:
+      image: node:22-alpine
+      stage: deploy
+      before_script:
+       - npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
+       - turbo config set token \${TURBOOPS_TOKEN}
+     script:
+       - turbo deploy test --wait
+     only:
+       - test  # NUR auf test Branch!
+
+   deploy-prod:
+     image: node:22-alpine
+     stage: deploy
+     before_script:
+       - npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
+       - turbo config set token \${TURBOOPS_TOKEN}
+     script:
+       - turbo deploy prod --wait
+     only:
+       - main  # NUR auf main Branch!
+
+WICHTIG:
+- Der Build l\xE4uft auf ALLEN Branches (dev, test, main)
+- Jeder Deploy-Job l\xE4uft NUR auf seinem zugeordneten Branch
+- KEIN --image Flag n\xF6tig - CLI erkennt CI_COMMIT_SHA/GITHUB_SHA automatisch
+- Registry-URL: ${configService.getRegistryUrl()}/${projectSlug}
+- Secrets ben\xF6tigt: TURBOOPS_TOKEN
+
+Erstelle die Datei "${pipelinePath}".`;
+}
+
 // src/utils/detect-project.ts
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
@@ -1644,10 +1899,71 @@ async function detectProjectConfig() {
   return result;
 }
 
-// src/commands/init.ts
-var initCommand = new Command3("init").description("Initialize TurboOps project in current directory").action(async () => {
-  const verbose = process.env.DEBUG === "true";
-  if (verbose) {
+// src/utils/env-examples.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2, statSync } from "fs";
+import { resolve } from "path";
+var DIR_TO_SERVICE = {
+  ".": "_root",
+  "projects/api": "api",
+  "projects/app": "app",
+  "packages/api": "api",
+  "packages/app": "app",
+  api: "api",
+  app: "app",
+  backend: "api",
+  frontend: "app",
+  server: "api",
+  client: "app"
+};
+function collectEnvExamples(options) {
+  const cwd = process.cwd();
+  const envFileNames = [".env.example", ".env.sample"];
+  const silent = options?.silent ?? false;
+  const result = { services: {} };
+  let found = false;
+  for (const [dir, serviceName] of Object.entries(DIR_TO_SERVICE)) {
+    for (const fileName of envFileNames) {
+      const filePath = resolve(cwd, dir, fileName);
+      if (!existsSync3(filePath)) {
+        continue;
+      }
+      const relativePath = dir === "." ? fileName : `${dir}/${fileName}`;
+      const fileSize = statSync(filePath).size;
+      if (fileSize > 64 * 1024) {
+        if (!silent) {
+          logger.warning(
+            `${relativePath} ist zu gro\xDF (> 64 KB) \u2014 \xFCbersprungen.`
+          );
+        }
+        break;
+      }
+      const content = readFileSync2(filePath, "utf-8");
+      found = true;
+      if (serviceName === "_root") {
+        result.root = content;
+        if (!silent) {
+          logger.info(
+            `${relativePath} gefunden \u2014 Stage-Umgebungsvariablen werden vorbereitet.`
+          );
+        }
+      } else if (!result.services[serviceName]) {
+        result.services[serviceName] = content;
+        if (!silent) {
+          logger.info(
+            `${relativePath} gefunden \u2014 Umgebungsvariablen f\xFCr Service "${serviceName}" werden vorbereitet.`
+          );
+        }
+      }
+      break;
+    }
+  }
+  return found ? result : void 0;
+}
+
+// src/commands/init.ts
+var initCommand = new Command3("init").description("Initialize TurboOps project in current directory").action(async () => {
+  const verbose = process.env.DEBUG === "true";
+  if (verbose) {
     console.log("[DEBUG] Verbose mode enabled");
   }
   logger.header("TurboOps Project Initialization");
@@ -1751,14 +2067,10 @@ async function setupProject(project, verbose = false) {
   const { data: environments } = await apiClient.getEnvironments(project.id);
   if (!environments || environments.length === 0) {
     logger.newline();
-    const { shouldCreateStage } = await prompts2({
-      initial: true,
-      message: "Das Projekt hat noch keine Stages. Standard-Stages erstellen (dev, test, prod)?",
-      name: "shouldCreateStage",
-      type: "confirm"
-    });
-    if (shouldCreateStage) {
-      await createDefaultStages(project.id, project.slug);
+    logger.info("Das Projekt hat noch keine Stages.");
+    const selectedStages = await selectStages();
+    if (selectedStages && selectedStages.length > 0) {
+      await createDefaultStages(project.id, project.slug, selectedStages);
     }
   }
   await offerAiAssistance(project.slug, project.id, verbose);
@@ -1859,45 +2171,62 @@ async function createNewProject(slug, verbose = false) {
   }
   configService.setProject(newProject.slug);
   logger.newline();
-  const { shouldCreateStage } = await prompts2({
-    initial: true,
-    message: "Standard-Stages erstellen (dev, test, prod)?",
-    name: "shouldCreateStage",
-    type: "confirm"
-  });
-  if (shouldCreateStage) {
-    await createDefaultStages(newProject.id, newProject.slug);
+  const selectedStages = await selectStages();
+  if (selectedStages && selectedStages.length > 0) {
+    await createDefaultStages(newProject.id, newProject.slug, selectedStages);
   }
   await offerAiAssistance(newProject.slug, newProject.id, verbose);
   await detectAndUploadCompose(newProject.slug);
   await showFinalSummary(newProject);
 }
-var DEFAULT_STAGES = [
+var AVAILABLE_STAGES = [
   {
     name: "Development",
     slug: "dev",
     type: "development",
     branch: "dev",
-    stageOrder: 0
+    selected: true
   },
   {
     name: "Test",
     slug: "test",
     type: "staging",
     branch: "test",
-    stageOrder: 1
+    selected: true
+  },
+  {
+    name: "Preview",
+    slug: "preview",
+    type: "preview",
+    branch: "",
+    selected: false
   },
   {
     name: "Production",
     slug: "prod",
     type: "production",
     branch: "main",
-    stageOrder: 2
+    selected: true
   }
 ];
-async function createDefaultStages(projectId, projectSlug) {
+async function selectStages() {
+  const { selectedSlugs } = await prompts2({
+    type: "multiselect",
+    name: "selectedSlugs",
+    message: "Welche Stages sollen erstellt werden?",
+    choices: AVAILABLE_STAGES.map((stage) => ({
+      title: `${stage.name} (${stage.slug})`,
+      value: stage.slug,
+      selected: stage.selected
+    })),
+    hint: "- Leertaste zum Ausw\xE4hlen, Enter zum Best\xE4tigen"
+  });
+  if (!selectedSlugs) return null;
+  return AVAILABLE_STAGES.filter((s) => selectedSlugs.includes(s.slug));
+}
+async function createDefaultStages(projectId, _projectSlug, stages) {
   logger.newline();
-  logger.header("Standard-Stages erstellen");
+  logger.header("Stages erstellen");
   const { baseDomain } = await prompts2({
     type: "text",
     name: "baseDomain",
@@ -1909,8 +2238,11 @@ async function createDefaultStages(projectId, projectSlug) {
     return;
   }
   logger.newline();
-  logger.info("Erstelle 3 Standard-Stages:");
-  for (const stage of DEFAULT_STAGES) {
+  logger.info(
+    `Erstelle ${stages.length} Stage${stages.length !== 1 ? "s" : ""}:`
+  );
+  for (let i = 0; i < stages.length; i++) {
+    const stage = stages[i];
     const domain = stage.type === "production" ? baseDomain : `${stage.slug}.${baseDomain}`;
     const { data: newStage, error } = await withSpinner(
       `Erstelle ${stage.name}...`,
@@ -1919,9 +2251,9 @@ async function createDefaultStages(projectId, projectSlug) {
         name: stage.name,
         slug: stage.slug,
         type: stage.type,
-        stageOrder: stage.stageOrder,
+        stageOrder: i,
         domain,
-        branch: stage.branch
+        branch: stage.branch || void 0
       })
     );
     if (error || !newStage) {
@@ -2031,7 +2363,11 @@ async function showFinalSummary(project) {
     logger.newline();
     logger.header("Verf\xFCgbare Stages");
     for (const env of environments) {
-      console.log(`  ${chalk5.bold(env.slug)} - ${env.name} (${env.type})`);
+      const services = env.services?.filter((s) => s.enabled !== false) || [];
+      const serviceInfo = services.length > 0 ? ` \u2192 Services: ${services.map((s) => s.name).join(", ")}` : "";
+      console.log(
+        `  ${chalk5.bold(env.slug)} - ${env.name} (${env.type})${chalk5.dim(serviceInfo)}`
+      );
     }
   }
   if (project.projectToken) {
@@ -2191,152 +2527,11 @@ async function offerAiAssistance(projectSlug, projectId, verbose = false) {
 async function createDockerSetupWithAI(projectId, verbose = false) {
   const tool = await aiToolsService.selectTool();
   if (!tool) return;
-  const prompt = `Analysiere dieses Projekt und erstelle ein Docker-Setup f\xFCr TurboOps Production Deployment.
-
-=== TURBOOPS ANFORDERUNGEN ===
-- docker-compose.yml MUSS auf Root-Ebene liegen
-- ALLE Abh\xE4ngigkeiten m\xFCssen enthalten sein (DB, Redis, etc.) - production-ready!
-- Images m\xFCssen immutable sein (keine Volume-Mounts f\xFCr Code)
-- Datenbank-Volumes f\xFCr Persistenz sind erlaubt (named volumes)
-- Environment-Variablen via \${VARIABLE} Syntax (werden zur Laufzeit injiziert)
-
-=== ZU ERSTELLENDE DATEIEN ===
-
-1. docker-compose.yml (Root-Ebene) - Datenbanken + Application Services
-   WICHTIG: Keine Environment-Variablen f\xFCr Application Services!
-   - Environment-Variablen f\xFCr api/app werden von TurboOps zur Deployment-Zeit injiziert
-   - Datenbanken bekommen ihre Konfiguration (Credentials kommen von TurboOps)
-\`\`\`yaml
-services:
-  # === DATENBANKEN ===
-  mongo:
-    image: mongo:7
-    volumes:
-      - mongo_data:/data/db
-    healthcheck:
-      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  redis:
-    image: redis:7-alpine
-    volumes:
-      - redis_data:/data
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  # === APPLICATION SERVICES (keine environment - kommt von TurboOps!) ===
-  # WICHTIG: image: muss gesetzt sein f\xFCr docker compose push!
-  api:
-    build:
-      context: .
-      dockerfile: ./projects/api/Dockerfile  # oder ./api/Dockerfile
-    image: \${IMAGE_NAME}/api:\${IMAGE_TAG:-latest}
-    expose:
-      - "3000"
-    depends_on:
-      - mongo
-      - redis
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-      start_period: 40s
-    restart: unless-stopped
-
-  app:
-    build:
-      context: .
-      dockerfile: ./projects/app/Dockerfile  # oder ./app/Dockerfile
-    image: \${IMAGE_NAME}/app:\${IMAGE_TAG:-latest}
-    expose:
-      - "3000"
-    depends_on:
-      - api
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-volumes:
-  mongo_data:
-  redis_data:
-\`\`\`
-
-2. Dockerfile f\xFCr jeden Service (im jeweiligen Ordner)
-   KRITISCH: IMMER --ignore-scripts bei npm ci verwenden!
-\`\`\`dockerfile
-# Stage 1: Dependencies
-FROM node:22-alpine AS deps
-WORKDIR /app
-COPY package*.json ./
-# KRITISCH: --ignore-scripts verhindert husky/prepare Fehler in Docker!
-RUN npm ci --ignore-scripts
-
-# Stage 2: Builder
-FROM node:22-alpine AS builder
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-RUN npm run build
-
-# Stage 3: Runner (Production)
-FROM node:22-alpine AS runner
-WORKDIR /app
-ENV NODE_ENV=production
-# Non-root user f\xFCr Sicherheit
-RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
-COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
-COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
-COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
-
-# Writable directories for runtime files (TUS uploads, temp processing)
-RUN mkdir -p /app/uploads/tus /app/temp && chown -R nodejs:nodejs /app/uploads /app/temp
-
-USER nodejs
-EXPOSE 3000
-CMD ["node", "dist/main.js"]
-\`\`\`
-
-3. .dockerignore (Root-Ebene)
-\`\`\`
-node_modules
-.git
-.env*
-*.log
-dist
-.nuxt
-.output
-coverage
-\`\`\`
-
-=== WICHTIGE REGELN F\xDCR TURBOOPS ===
-- KRITISCH: IMMER \`npm ci --ignore-scripts\` verwenden (verhindert husky/prepare Fehler!)
-- KRITISCH: KEINE \`ports:\` \u2192 Verwende \`expose:\` (nur im Docker-Netzwerk sichtbar)
-- KRITISCH: KEINE \`environment:\` f\xFCr Application Services (api, app) \u2192 Env-Variablen werden von TurboOps zur Deployment-Zeit injiziert
-- Datenbank-Services (mongo, redis, etc.) OHNE environment - Credentials kommen von TurboOps
-- Ein Reverse-Proxy (Traefik) routet externe Anfragen
-- Pr\xFCfe die tats\xE4chliche Projektstruktur (projects/, packages/, apps/, oder flach)
-- Passe Dockerfile-Pfade entsprechend an
-- NestJS: CMD ["node", "dist/main.js"]
-- Nuxt: CMD ["node", ".output/server/index.mjs"]
-- Nutze wget statt curl f\xFCr healthchecks (curl nicht in alpine)
-- Named volumes f\xFCr Datenbank-Persistenz (mongo_data, redis_data, etc.)
-- Keine Code-Volume-Mounts (Code ist im Image)
-- depends_on mit condition: service_healthy f\xFCr korrekten Start-Order
-- Erkenne ben\xF6tigte Services aus package.json (mongoose \u2192 mongo, ioredis \u2192 redis, etc.)
-
-Erstelle alle notwendigen Dateien basierend auf der erkannten Projektstruktur und Abh\xE4ngigkeiten.`;
-  const success = await aiToolsService.runWithPrompt(tool, prompt, verbose);
+  const success = await aiToolsService.runWithPrompt(
+    tool,
+    DOCKER_SETUP_PROMPT,
+    verbose
+  );
   if (success) {
     logger.success("Docker-Setup wurde erstellt!");
     await apiClient.updateProjectConfig(projectId, {
@@ -2353,12 +2548,12 @@ async function detectAndUploadCompose(projectSlug) {
   if (!composePath) {
     return;
   }
-  const fullPath = resolve(process.cwd(), composePath);
-  if (!existsSync3(fullPath)) {
+  const fullPath = resolve2(process.cwd(), composePath);
+  if (!existsSync4(fullPath)) {
     return;
   }
   try {
-    const content = readFileSync2(fullPath, "utf-8");
+    const content = readFileSync3(fullPath, "utf-8");
     const envExamples = collectEnvExamples();
     const { error } = await apiClient.uploadCompose(
       project.id,
@@ -2384,8 +2579,8 @@ async function integratePipelineWithAI(detection, projectSlug, verbose = false,
   const tool = await aiToolsService.selectTool();
   if (!tool) return;
   const pipelineType = detection.hasGitLabPipeline ? "gitlab" : "github";
-  const pipelineFile = detection.pipelinePath;
-  let templateContent = "";
+  const pipelineFile = detection.pipelinePath || (pipelineType === "github" ? ".github/workflows/deploy.yml" : ".gitlab-ci.yml");
+  let templateContent;
   if (projectId) {
     const { data: pipelineTemplate, error } = await withSpinner(
       "Lade TurboOps Pipeline-Template...",
@@ -2400,176 +2595,33 @@ async function integratePipelineWithAI(detection, projectSlug, verbose = false,
       templateContent = pipelineTemplate.content;
     }
   }
-  const pipelineTypeName = pipelineType === "gitlab" ? "GitLab CI" : "GitHub Actions";
-  const prompt = templateContent ? `WICHTIG: Integriere das TurboOps Deployment-Template EXAKT wie vorgegeben in die bestehende ${pipelineTypeName} Pipeline.
-
-Bestehende Pipeline-Datei: ${pipelineFile}
-
-=== TURBOOPS TEMPLATE (NICHT VER\xC4NDERN!) ===
-\`\`\`yaml
-${templateContent}
-\`\`\`
-=== ENDE TEMPLATE ===
-
-STRIKTE REGELN:
-1. Das TurboOps Template MUSS EXAKT so \xFCbernommen werden wie oben angegeben
-2. KEINE \xC4nderungen an:
-   - Variables (IMAGE_NAME, DOCKER_TLS_CERTDIR)
-   - Job-Namen (build, deploy-dev, deploy-test, deploy-prod)
-   - Script-Befehlen (turbo deploy, docker build, etc.)
-   - Branch-Rules (die sind korrekt f\xFCr die konfigurierten Stages)
-   - needs/dependencies zwischen Jobs
-3. NUR erlaubte \xC4nderungen:
-   - Stages der bestehenden Pipeline VOR den TurboOps-Stages einf\xFCgen
-   - Bestehende Jobs der Pipeline BEHALTEN (z.B. lint, test)
-   - TurboOps "build" Job muss von bestehenden Build-Jobs abh\xE4ngen (needs)
-
-MERGE-STRATEGIE:
-- Bestehende stages: [lint, test, build] + TurboOps stages: [build, deploy-dev, deploy-test, deploy-prod]
-- Ergebnis: stages: [lint, test, build, turboops-build, deploy-dev, deploy-test, deploy-prod]
-- Der TurboOps "build" Job sollte in "turboops-build" umbenannt werden falls es bereits einen "build" Job gibt
-- turboops-build needs: [build] (vom bestehenden build Job)
-
-Modifiziere die Datei "${pipelineFile}" entsprechend.` : `Erstelle eine neue ${pipelineTypeName} Pipeline f\xFCr TurboOps Deployment.
-
-Projekt-Slug: ${projectSlug}
-Pipeline-Datei: ${pipelineFile}
-
-WICHTIG - Branch-zu-Stage-Zuordnung (STRIKT EINHALTEN!):
-- dev Stage \u2192 deployed NUR wenn Branch == "dev"
-- test Stage \u2192 deployed NUR wenn Branch == "test"
-- prod Stage \u2192 deployed NUR wenn Branch == "main"
-
-PIPELINE-STRUKTUR:
-
-1. BUILD-JOB (l\xE4uft NUR auf dem default branch z.B. dev):
-   stages: [build, deploy]
-
-   build:
-     image: docker:24-dind
-     stage: build
-     services: [docker:24-dind]
-     before_script:
-       - docker login -u ${projectSlug} -p \${TURBOOPS_TOKEN} ${configService.getRegistryUrl()}
-     script:
-       - docker compose -f docker-compose.yml build
-       - docker compose -f docker-compose.yml push
-     only:
-       - dev  # L\xE4uft nur auf dem default branch
-
-2. DEPLOY-JOBS (jeder NUR auf seinem Branch!):
-   WICHTIG: KEIN --image Flag n\xF6tig! Die CLI erkennt CI_COMMIT_SHA automatisch!
-
-   deploy-dev:
-     image: node:22-alpine
-     stage: deploy
-     before_script:
-       - npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
-       - turbo config set token \${TURBOOPS_TOKEN}
-     script:
-       - turbo deploy dev --wait  # CLI erkennt Image automatisch via CI_COMMIT_SHA
-     only:
-       - dev  # NUR auf dev Branch!
-
-   deploy-test:
-      image: node:22-alpine
-      stage: deploy
-      before_script:
-       - npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
-       - turbo config set token \${TURBOOPS_TOKEN}
-     script:
-       - turbo deploy test --wait
-     only:
-       - test  # NUR auf test Branch!
-
-   deploy-prod:
-     image: node:22-alpine
-     stage: deploy
-     before_script:
-       - npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
-       - turbo config set token \${TURBOOPS_TOKEN}
-     script:
-       - turbo deploy prod --wait
-     only:
-       - main  # NUR auf main Branch!
-
-WICHTIG:
-- Der Build l\xE4uft auf ALLEN Branches (dev, test, main)
-- Jeder Deploy-Job l\xE4uft NUR auf seinem zugeordneten Branch
-- KEIN --image Flag n\xF6tig - CLI erkennt CI_COMMIT_SHA/GITHUB_SHA automatisch
-- Registry-URL: ${configService.getRegistryUrl()}/${projectSlug}
-- Secrets ben\xF6tigt: TURBOOPS_TOKEN
-
-Erstelle die Datei "${pipelineFile}".`;
-  const success = await aiToolsService.runWithPrompt(tool, prompt, verbose);
-  if (success) {
-    logger.success("Pipeline wurde mit AI aktualisiert!");
-    if (projectId) {
-      await apiClient.updateProjectConfig(projectId, {
-        pipelineConfig: {
-          hasPipeline: true,
-          pipelineType
-        }
-      });
-    }
-    logger.newline();
-    logger.info(
-      "Vergessen Sie nicht, das CI/CD Secret TURBOOPS_TOKEN zu konfigurieren."
-    );
-  }
-}
-var DIR_TO_SERVICE = {
-  ".": "_root",
-  "projects/api": "api",
-  "projects/app": "app",
-  "packages/api": "api",
-  "packages/app": "app",
-  api: "api",
-  app: "app",
-  backend: "api",
-  frontend: "app",
-  server: "api",
-  client: "app"
-};
-function collectEnvExamples() {
-  const cwd = process.cwd();
-  const envFileNames = [".env.example", ".env.sample"];
-  const result = { services: {} };
-  let found = false;
-  for (const [dir, serviceName] of Object.entries(DIR_TO_SERVICE)) {
-    for (const fileName of envFileNames) {
-      const filePath = resolve(cwd, dir, fileName);
-      if (!existsSync3(filePath)) {
-        continue;
-      }
-      const relativePath = dir === "." ? fileName : `${dir}/${fileName}`;
-      const fileSize = statSync(filePath).size;
-      if (fileSize > 64 * 1024) {
-        logger.warning(`${relativePath} ist zu gro\xDF (> 64 KB) \u2014 \xFCbersprungen.`);
-        break;
-      }
-      const content = readFileSync2(filePath, "utf-8");
-      found = true;
-      if (serviceName === "_root") {
-        result.root = content;
-        logger.info(
-          `${relativePath} gefunden \u2014 Stage-Umgebungsvariablen werden vorbereitet.`
-        );
-      } else if (!result.services[serviceName]) {
-        result.services[serviceName] = content;
-        logger.info(
-          `${relativePath} gefunden \u2014 Umgebungsvariablen f\xFCr Service "${serviceName}" werden vorbereitet.`
-        );
-      }
-      break;
-    }
-  }
-  return found ? result : void 0;
-}
+  const prompt = buildPipelineIntegrationPrompt(
+    pipelineType,
+    projectSlug,
+    pipelineFile,
+    templateContent
+  );
+  const success = await aiToolsService.runWithPrompt(tool, prompt, verbose);
+  if (success) {
+    logger.success("Pipeline wurde mit AI aktualisiert!");
+    if (projectId) {
+      await apiClient.updateProjectConfig(projectId, {
+        pipelineConfig: {
+          hasPipeline: true,
+          pipelineType
+        }
+      });
+    }
+    logger.newline();
+    logger.info(
+      "Vergessen Sie nicht, das CI/CD Secret TURBOOPS_TOKEN zu konfigurieren."
+    );
+  }
+}
 
 // src/commands/deploy.ts
-import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync4, existsSync as existsSync5 } from "fs";
+import { resolve as resolve3 } from "path";
 import { Command as Command4 } from "commander";
 import chalk6 from "chalk";
 var DOCKER_TAG_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
@@ -2637,20 +2689,20 @@ var deployCommand = new Command4("deploy").description("Trigger a deployment (fo
   let composeFileContent;
   if (isFirstStage) {
     if (typeof options.compose === "string") {
-      const composePath = resolve2(options.compose);
-      if (!existsSync4(composePath)) {
+      const composePath = resolve3(options.compose);
+      if (!existsSync5(composePath)) {
         logger.error(`Compose file not found: ${composePath}`);
         process.exit(11 /* CONFIG_ERROR */);
       }
-      composeFileContent = readFileSync3(composePath, "utf-8");
+      composeFileContent = readFileSync4(composePath, "utf-8");
       logger.info(`Using compose file: ${composePath}`);
     } else if (project.detectedConfig?.composePath) {
-      const composePath = resolve2(
+      const composePath = resolve3(
         process.cwd(),
         project.detectedConfig.composePath
       );
-      if (existsSync4(composePath)) {
-        composeFileContent = readFileSync3(composePath, "utf-8");
+      if (existsSync5(composePath)) {
+        composeFileContent = readFileSync4(composePath, "utf-8");
         logger.info(
           `Using project compose file: ${project.detectedConfig.composePath}`
         );
@@ -2679,11 +2731,13 @@ var deployCommand = new Command4("deploy").description("Trigger a deployment (fo
       `Stage "${env.name}" uses promotion \u2014 compose file from previous stage`
     );
   }
+  const envExamples = collectEnvExamples({ silent: true });
   logger.info("Triggering deployment...");
   const { data: deployment, error } = await apiClient.deploy(
     env.id,
     imageTag,
-    composeFileContent
+    composeFileContent,
+    envExamples
   );
   if (error) {
     logger.error(`Failed to trigger deployment: ${error}`);
@@ -2732,15 +2786,20 @@ var deployCommand = new Command4("deploy").description("Trigger a deployment (fo
       logger.newline();
       logger.success("Deployment completed successfully!");
       if (finalStatus.healthStatus) {
-        logger.info(
-          `Health: ${finalStatus.healthStatus.healthy}/${finalStatus.healthStatus.total} containers healthy`
-        );
+        const { healthy, total } = finalStatus.healthStatus;
+        const allHealthy = healthy >= total;
+        const healthMsg = `Health: ${healthy}/${total} containers healthy`;
+        if (allHealthy) {
+          console.log(chalk6.green(`  \u2713 ${healthMsg}`));
+        } else {
+          console.log(chalk6.yellow(`  \u26A0 ${healthMsg}`));
+        }
       }
     } else if (finalStatus.status === "failed") {
       logger.newline();
-      logger.error("Deployment failed!");
+      console.log(chalk6.red.bold("  \u2717 Deployment failed!"));
       if (finalStatus.errorMessage) {
-        logger.error(`Error: ${finalStatus.errorMessage}`);
+        console.log(chalk6.red(`  Error: ${finalStatus.errorMessage}`));
       }
       await printContainerLogs(env.id);
       process.exit(1 /* ERROR */);
@@ -2775,9 +2834,10 @@ async function printContainerLogs(stageId) {
       const time = new Date(log.timestamp).toLocaleTimeString();
       const levelColor = getLogLevelColor(log.level);
       const container = log.container ? chalk6.dim(`[${log.container}]`) : "";
+      const message = isErrorLevel(log.level) ? chalk6.red(log.message) : log.message;
       if (!isJsonMode()) {
         console.log(
-          `  ${chalk6.dim(time)} ${levelColor(log.level.padEnd(5))} ${container} ${log.message}`
+          `  ${chalk6.dim(time)} ${levelColor(log.level.padEnd(5))} ${container} ${message}`
         );
       }
     }
@@ -2785,6 +2845,9 @@ async function printContainerLogs(stageId) {
   } catch {
   }
 }
+function isErrorLevel(level) {
+  return ["error", "fatal", "err", "crit"].includes(level.toLowerCase());
+}
 function getLogLevelColor(level) {
   switch (level.toLowerCase()) {
     case "error":
@@ -3018,190 +3081,37 @@ async function showSecrets(projectId, pipelineType) {
 async function createDockerSetupWithAI2() {
   const tool = await aiToolsService.selectTool();
   if (!tool) return;
-  const prompt = `Analysiere dieses Projekt und erstelle ein vollst\xE4ndiges Docker-Setup f\xFCr Production Deployment.
-
-**Wichtig: TurboOps ben\xF6tigt eine docker-compose.yml auf Root-Ebene!**
-
-KRITISCHE ANFORDERUNGEN:
-
-1. docker-compose.yml im Projekt-Root:
-   - Services f\xFCr alle Komponenten (api, app, etc.)
-   - Verwende build-Direktive mit Pfad zu den Dockerfiles
-   - KEINE version: Angabe (deprecated)
-   - Health-Checks f\xFCr alle Services
-
-2. Dockerfiles - WICHTIGE REGELN:
-   - Multi-stage builds (deps -> builder -> runner)
-   - IMMER \`npm ci --ignore-scripts\` verwenden (verhindert husky/prepare Fehler!)
-   - Non-root User f\xFCr Production
-   - Minimales Base-Image (node:22-alpine)
-
-3. .dockerignore auf Root-Ebene:
-   - node_modules, .git, dist, .env*, *.log
-
-4. Monorepo-Struktur beachten:
-   - Pr\xFCfe projects/, packages/, apps/ Ordner
-   - Context muss Root sein f\xFCr Monorepo-Zugriff
-
-DOCKERFILE-TEMPLATE (STRIKT EINHALTEN!):
-\`\`\`dockerfile
-# Stage 1: Dependencies
-FROM node:22-alpine AS deps
-WORKDIR /app
-COPY package*.json ./
-# WICHTIG: --ignore-scripts verhindert husky/prepare Fehler!
-RUN npm ci --ignore-scripts
-
-# Stage 2: Builder
-FROM node:22-alpine AS builder
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-RUN npm run build
-
-# Stage 3: Runner (Production)
-FROM node:22-alpine AS runner
-WORKDIR /app
-ENV NODE_ENV=production
-RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
-COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
-COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
-COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
-
-# Writable directories for runtime files (TUS uploads, temp processing)
-RUN mkdir -p /app/uploads/tus /app/temp && chown -R nodejs:nodejs /app/uploads /app/temp
-
-USER nodejs
-EXPOSE 3000
-CMD ["node", "dist/main.js"]
-\`\`\`
-
-docker-compose.yml TEMPLATE:
-\`\`\`yaml
-services:
-  # === DATENBANKEN (erkenne aus package.json: mongoose \u2192 mongo, ioredis \u2192 redis) ===
-  mongo:
-    image: mongo:7
-    volumes:
-      - mongo_data:/data/db
-    healthcheck:
-      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  redis:
-    image: redis:7-alpine
-    volumes:
-      - redis_data:/data
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  # === APPLICATION SERVICES (KEINE environment!) ===
-  # WICHTIG: image: muss gesetzt sein f\xFCr docker compose push!
-  api:
-    build:
-      context: .
-      dockerfile: projects/api/Dockerfile
-    image: \${IMAGE_NAME}/api:\${IMAGE_TAG:-latest}
-    expose:
-      - "3000"
-    depends_on:
-      mongo:
-        condition: service_healthy
-      redis:
-        condition: service_healthy
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  app:
-    build:
-      context: .
-      dockerfile: projects/app/Dockerfile
-    image: \${IMAGE_NAME}/app:\${IMAGE_TAG:-latest}
-    expose:
-      - "3000"
-    depends_on:
-      api:
-        condition: service_healthy
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-volumes:
-  mongo_data:
-  redis_data:
-\`\`\`
-
-WICHTIG - TURBOOPS DEPLOYMENT:
-- KEINE \`ports:\` \u2192 Verwende \`expose:\` (nur im Docker-Netzwerk sichtbar)
-- KEINE \`environment:\` f\xFCr Application Services \u2192 Env-Variablen werden von TurboOps zur Deployment-Zeit injiziert
-- Datenbanken OHNE environment - Credentials kommen von TurboOps
-- Ein Reverse-Proxy (Traefik) routet externe Anfragen
-- Verhindert Port-Konflikte bei mehreren Projekten auf einem Server
-
-Erstelle alle notwendigen Dateien.`;
-  const success = await aiToolsService.runWithPrompt(tool, prompt);
+  const success = await aiToolsService.runWithPrompt(tool, DOCKER_SETUP_PROMPT);
   if (success) {
     logger.success("Docker-Setup wurde erstellt!");
   }
 }
 async function integratePipelineWithAI2(pipelineType, projectSlug, pipelinePath) {
+  const { project } = await getCommandContext();
   const tool = await aiToolsService.selectTool();
   if (!tool) {
     addJsonData({ generated: false, reason: "no_ai_tool" });
     return;
   }
-  const typeName = pipelineType === "gitlab" ? "GitLab CI" : "GitHub Actions";
-  const prompt = `Integriere TurboOps Deployment in die bestehende ${typeName} Pipeline.
-
-Projekt-Slug: ${projectSlug}
-Pipeline-Datei: ${pipelinePath}
-
-WICHTIG - Branch-zu-Stage-Zuordnung:
-- dev Stage \u2192 wird NUR auf dem "dev" Branch deployed
-- test Stage \u2192 wird NUR auf dem "test" Branch deployed
-- prod Stage \u2192 wird NUR auf dem "main" Branch deployed
-
-PIPELINE-STRUKTUR:
-1. Build-Job: L\xE4uft auf ALLEN Branches (dev, test, main)
-   - Docker Images bauen mit docker-compose build
-   - Images pushen mit docker-compose push
-   - Registry: ${configService.getRegistryUrl()}/${projectSlug}
-   - Image-Tag: \${CI_COMMIT_SHA} (wird automatisch von CLI erkannt)
-
-2. Deploy-Jobs: Jeder Job l\xE4uft NUR auf seinem Branch!
-   - deploy-dev: rules: if: $CI_COMMIT_BRANCH == "dev"
-   - deploy-test: rules: if: $CI_COMMIT_BRANCH == "test"
-   - deploy-prod: rules: if: $CI_COMMIT_BRANCH == "main" (when: manual)
-
-DEPLOY-BEFEHLE (WICHTIG: KEIN --image Flag n\xF6tig!):
-- TurboOps CLI installieren: npm install -g @turboops/cli${configService.getEnvironment() === "dev" ? "@dev" : ""}
-- Token setzen: turbo config set token \${TURBOOPS_TOKEN}
-- Deploy: turbo deploy <stage> --wait
-
-Die CLI erkennt automatisch CI_COMMIT_SHA/GITHUB_SHA und verwendet das richtige Image!
-
-DEPENDENCIES:
-- deploy-dev needs: [build]
-- deploy-test needs: [deploy-dev]
-- deploy-prod needs: [deploy-test]
-
-Secrets ben\xF6tigt: TURBOOPS_TOKEN
-
-Modifiziere die Datei "${pipelinePath}" entsprechend.`;
+  let templateContent;
+  const { data: pipelineTemplate, error } = await withSpinner(
+    "Lade TurboOps Pipeline-Template...",
+    () => apiClient.generatePipeline(project.id, pipelineType)
+  );
+  if (error || !pipelineTemplate) {
+    logger.warning(
+      `Pipeline-Template konnte nicht geladen werden: ${error || "Unbekannter Fehler"}`
+    );
+    logger.info("AI wird ein generisches Template verwenden.");
+  } else {
+    templateContent = pipelineTemplate.content;
+  }
+  const prompt = buildPipelineIntegrationPrompt(
+    pipelineType,
+    projectSlug,
+    pipelinePath,
+    templateContent
+  );
   const success = await aiToolsService.runWithPrompt(tool, prompt);
   if (success) {
     logger.success("Pipeline wurde mit AI aktualisiert!");
@@ -3218,143 +3128,6 @@ Modifiziere die Datei "${pipelinePath}" entsprechend.`;
 // src/commands/docker.ts
 import { Command as Command6 } from "commander";
 import prompts4 from "prompts";
-var DOCKER_SETUP_PROMPT = `Analysiere dieses Projekt und erstelle ein vollst\xE4ndiges Docker-Setup f\xFCr Production Deployment.
-
-**Wichtig: TurboOps ben\xF6tigt eine docker-compose.yml auf Root-Ebene!**
-
-KRITISCHE ANFORDERUNGEN:
-
-1. docker-compose.yml im Projekt-Root:
-   - Services f\xFCr alle Komponenten (api, app, etc.)
-   - Verwende build-Direktive mit Pfad zu den Dockerfiles
-   - KEINE version: Angabe (deprecated)
-   - Health-Checks f\xFCr alle Services
-
-2. Dockerfiles - WICHTIGE REGELN:
-   - Multi-stage builds (deps -> builder -> runner)
-   - IMMER \`npm ci --ignore-scripts\` verwenden (verhindert husky/prepare Fehler!)
-   - Non-root User f\xFCr Production
-   - Minimales Base-Image (node:22-alpine)
-
-3. .dockerignore auf Root-Ebene:
-   - node_modules, .git, dist, .env*, *.log
-
-4. Monorepo-Struktur beachten:
-   - Pr\xFCfe projects/, packages/, apps/ Ordner
-   - Context muss Root sein f\xFCr Monorepo-Zugriff
-
-DOCKERFILE-TEMPLATE (STRIKT EINHALTEN!):
-\`\`\`dockerfile
-# Stage 1: Dependencies
-FROM node:22-alpine AS deps
-WORKDIR /app
-COPY package*.json ./
-# WICHTIG: --ignore-scripts verhindert husky/prepare Fehler!
-RUN npm ci --ignore-scripts
-
-# Stage 2: Builder
-FROM node:22-alpine AS builder
-WORKDIR /app
-COPY --from=deps /app/node_modules ./node_modules
-COPY . .
-RUN npm run build
-
-# Stage 3: Runner (Production)
-FROM node:22-alpine AS runner
-WORKDIR /app
-ENV NODE_ENV=production
-
-# Non-root user
-RUN addgroup -g 1001 -S nodejs && adduser -S nodejs -u 1001
-
-COPY --from=builder --chown=nodejs:nodejs /app/dist ./dist
-COPY --from=builder --chown=nodejs:nodejs /app/node_modules ./node_modules
-COPY --from=builder --chown=nodejs:nodejs /app/package.json ./
-
-# Writable directories for runtime files (TUS uploads, temp processing)
-RUN mkdir -p /app/uploads/tus /app/temp && chown -R nodejs:nodejs /app/uploads /app/temp
-
-USER nodejs
-
-EXPOSE 3000
-CMD ["node", "dist/main.js"]
-\`\`\`
-
-docker-compose.yml TEMPLATE:
-\`\`\`yaml
-services:
-  # === DATENBANKEN (erkenne aus package.json: mongoose \u2192 mongo, ioredis \u2192 redis) ===
-  mongo:
-    image: mongo:7
-    volumes:
-      - mongo_data:/data/db
-    healthcheck:
-      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  redis:
-    image: redis:7-alpine
-    volumes:
-      - redis_data:/data
-    healthcheck:
-      test: ["CMD", "redis-cli", "ping"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  # === APPLICATION SERVICES (KEINE environment!) ===
-  # WICHTIG: image: muss gesetzt sein f\xFCr docker compose push!
-  # Format: \${IMAGE_NAME:-registry/project}/service:\${IMAGE_TAG:-latest}
-  api:
-    build:
-      context: .
-      dockerfile: projects/api/Dockerfile
-    image: \${IMAGE_NAME}/api:\${IMAGE_TAG:-latest}
-    expose:
-      - "3000"
-    depends_on:
-      - mongo
-      - redis
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000/health"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-  app:
-    build:
-      context: .
-      dockerfile: projects/app/Dockerfile
-    image: \${IMAGE_NAME}/app:\${IMAGE_TAG:-latest}
-    expose:
-      - "3000"
-    depends_on:
-      - api
-    healthcheck:
-      test: ["CMD", "wget", "-q", "--spider", "http://localhost:3000"]
-      interval: 30s
-      timeout: 10s
-      retries: 3
-    restart: unless-stopped
-
-volumes:
-  mongo_data:
-  redis_data:
-\`\`\`
-
-WICHTIG - TURBOOPS DEPLOYMENT:
-- KEINE \`ports:\` \u2192 Verwende \`expose:\` (nur im Docker-Netzwerk sichtbar)
-- KEINE \`environment:\` f\xFCr Application Services \u2192 Env-Variablen werden von TurboOps zur Deployment-Zeit injiziert
-- Datenbanken OHNE environment - Credentials kommen von TurboOps
-- Ein Reverse-Proxy (Traefik) routet externe Anfragen
-- Verhindert Port-Konflikte bei mehreren Projekten auf einem Server
-
-Erstelle alle notwendigen Dateien.`;
 var dockerCommand = new Command6("docker").description(
   "Manage Docker configuration"
 );