@turboops/cli 1.0.0-dev.584 → 1.0.0-dev.586

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command7 } from "commander";
+import { Command as Command8 } from "commander";
 import chalk8 from "chalk";
 
 // src/services/config.ts
@@ -135,9 +135,9 @@ function loadPackageJson() {
     join(__dirname, "../package.json")
     // From dist/
   ];
-  for (const path3 of paths) {
-    if (existsSync(path3)) {
-      return require2(path3);
+  for (const path4 of paths) {
+    if (existsSync(path4)) {
+      return require2(path4);
     }
   }
   return { version: "0.0.0", name: "@turboops/cli" };
@@ -432,7 +432,7 @@ var apiClient = {
   /**
    * Make an API request
    */
-  async request(method, path3, body) {
+  async request(method, path4, body) {
     const apiUrl = configService.getApiUrl();
     const token = configService.getToken();
     if (!token) {
@@ -441,7 +441,7 @@ var apiClient = {
         status: 401
       };
     }
-    const url = `${apiUrl}${path3}`;
+    const url = `${apiUrl}${path4}`;
     const headers = {
       "Content-Type": "application/json",
       Authorization: `Bearer ${token}`
@@ -455,14 +455,35 @@ var apiClient = {
         fetchOptions.body = JSON.stringify(body);
       }
       const response = await fetch(url, fetchOptions);
-      const data = await response.json().catch(() => null);
+      const text = await response.text();
+      let data = null;
+      try {
+        data = text ? JSON.parse(text) : null;
+      } catch {
+        if (!response.ok) {
+          return {
+            error: `HTTP ${response.status}: ${text || "No response body"}`,
+            status: response.status
+          };
+        }
+      }
       if (!response.ok) {
         const errorData = data;
+        const errorMessage = errorData?.message || errorData?.error || `HTTP ${response.status}`;
+        return {
+          error: errorMessage,
+          status: response.status
+        };
+      }
+      if (data === null || data === void 0) {
         return {
-          error: errorData?.message || `HTTP ${response.status}`,
+          error: `Empty response from server (HTTP ${response.status})`,
           status: response.status
         };
       }
+      if (process.env.DEBUG) {
+        console.debug("[API] Response:", JSON.stringify(data, null, 2).substring(0, 500));
+      }
       return { data, status: response.status };
     } catch (error) {
       const message = error instanceof Error ? error.message : "Network error";
@@ -599,10 +620,10 @@ var apiClient = {
     return this.request("POST", "/deployment/projects/simple", payload);
   },
   /**
-   * Get all customers
+   * Get all customers (simplified list for selection)
    */
   async getCustomers() {
-    return this.request("GET", "/customer");
+    return this.request("GET", "/customer/simple");
   },
   /**
    * Get environments (stages) for project
@@ -1187,14 +1208,172 @@ function getStatusColor(status) {
 
 // src/commands/init.ts
 import { Command as Command3 } from "commander";
+import prompts2 from "prompts";
+
+// src/services/ai-tools.ts
+import { execSync, spawn } from "child_process";
 import prompts from "prompts";
+var AI_TOOLS = {
+  claude: {
+    name: "Claude Code",
+    command: "claude",
+    promptFlag: "-p"
+  },
+  codex: {
+    name: "OpenAI Codex",
+    command: "codex",
+    promptFlag: ""
+  }
+};
+var aiToolsService = {
+  /**
+   * Check which AI tools are installed locally
+   */
+  getAvailableTools() {
+    const available = [];
+    const whichCommand = process.platform === "win32" ? "where" : "which";
+    for (const [key, config] of Object.entries(AI_TOOLS)) {
+      try {
+        execSync(`${whichCommand} ${config.command}`, { stdio: "ignore" });
+        available.push(key);
+      } catch {
+      }
+    }
+    return available;
+  },
+  /**
+   * Interactive tool selection
+   * Returns null if no tools available or user cancels
+   */
+  async selectTool() {
+    const available = this.getAvailableTools();
+    if (available.length === 0) {
+      logger.error("Kein AI-Tool gefunden. Bitte installieren Sie Claude Code oder OpenAI Codex.");
+      logger.newline();
+      logger.info("  Claude Code: https://claude.ai/code");
+      logger.info("  OpenAI Codex: https://openai.com/codex");
+      return null;
+    }
+    if (available.length === 1) {
+      logger.info(`Verwende ${AI_TOOLS[available[0]].name}`);
+      return available[0];
+    }
+    const { selectedTool } = await prompts({
+      type: "select",
+      name: "selectedTool",
+      message: "AI-Tool ausw\xE4hlen:",
+      choices: available.map((tool) => ({
+        title: AI_TOOLS[tool].name,
+        value: tool
+      }))
+    });
+    return selectedTool || null;
+  },
+  /**
+   * Run AI tool with a prompt in the current directory
+   * The tool runs interactively, inheriting stdio
+   */
+  async runWithPrompt(tool, prompt) {
+    const config = AI_TOOLS[tool];
+    logger.newline();
+    logger.info(`Starte ${config.name}...`);
+    logger.info("Das AI-Tool wird interaktiv ausgef\xFChrt. Folgen Sie den Anweisungen.");
+    logger.newline();
+    return new Promise((resolve2) => {
+      const args = config.promptFlag ? [config.promptFlag, prompt] : [prompt];
+      const child = spawn(config.command, args, {
+        stdio: "inherit",
+        cwd: process.cwd(),
+        shell: process.platform === "win32"
+      });
+      child.on("close", (code) => {
+        logger.newline();
+        resolve2(code === 0);
+      });
+      child.on("error", (err) => {
+        logger.error(`Fehler beim Ausf\xFChren von ${config.name}: ${err.message}`);
+        resolve2(false);
+      });
+    });
+  }
+};
+
+// src/utils/detect-project.ts
+import * as fs2 from "fs/promises";
+import * as path2 from "path";
+async function detectProjectConfig() {
+  const cwd = process.cwd();
+  const result = {
+    hasDockerfile: false,
+    hasDockerCompose: false,
+    hasGitLabPipeline: false,
+    hasGitHubPipeline: false,
+    hasTurboOpsInPipeline: false
+  };
+  const dockerfilePaths = [
+    "Dockerfile",
+    "dockerfile",
+    "docker/Dockerfile",
+    "api/Dockerfile",
+    "app/Dockerfile",
+    "projects/api/Dockerfile",
+    "projects/app/Dockerfile"
+  ];
+  for (const dockerPath of dockerfilePaths) {
+    try {
+      await fs2.access(path2.join(cwd, dockerPath));
+      result.hasDockerfile = true;
+      result.dockerfilePath = dockerPath;
+      break;
+    } catch {
+    }
+  }
+  const composePaths = ["docker-compose.yml", "docker-compose.yaml", "compose.yml", "compose.yaml"];
+  for (const composePath of composePaths) {
+    try {
+      await fs2.access(path2.join(cwd, composePath));
+      result.hasDockerCompose = true;
+      break;
+    } catch {
+    }
+  }
+  const gitlabPath = path2.join(cwd, ".gitlab-ci.yml");
+  try {
+    await fs2.access(gitlabPath);
+    result.hasGitLabPipeline = true;
+    result.pipelinePath = ".gitlab-ci.yml";
+    const content = await fs2.readFile(gitlabPath, "utf-8");
+    result.hasTurboOpsInPipeline = content.includes("turbo deploy") || content.includes("@turboops/cli");
+  } catch {
+  }
+  const githubPath = path2.join(cwd, ".github", "workflows");
+  try {
+    const files = await fs2.readdir(githubPath);
+    const ymlFiles = files.filter((f) => f.endsWith(".yml") || f.endsWith(".yaml"));
+    if (ymlFiles.length > 0) {
+      result.hasGitHubPipeline = true;
+      result.pipelinePath = `.github/workflows/${ymlFiles[0]}`;
+      for (const file of ymlFiles) {
+        const content = await fs2.readFile(path2.join(githubPath, file), "utf-8");
+        if (content.includes("turbo deploy") || content.includes("@turboops/cli")) {
+          result.hasTurboOpsInPipeline = true;
+          break;
+        }
+      }
+    }
+  } catch {
+  }
+  return result;
+}
+
+// src/commands/init.ts
 import chalk4 from "chalk";
 var initCommand = new Command3("init").description("Initialize TurboOps project in current directory").action(async () => {
   logger.header("TurboOps Project Initialization");
   if (!configService.isAuthenticated()) {
     logger.warning("Nicht authentifiziert. Bitte melden Sie sich zuerst an.");
     logger.newline();
-    const { shouldLogin } = await prompts({
+    const { shouldLogin } = await prompts2({
       initial: true,
       message: "M\xF6chten Sie sich jetzt anmelden?",
       name: "shouldLogin",
@@ -1218,7 +1397,7 @@ var initCommand = new Command3("init").description("Initialize TurboOps project
     logger.success(`Angemeldet als ${result.user?.email || "Unknown"}`);
   }
   logger.newline();
-  const { projectSlug } = await prompts({
+  const { projectSlug } = await prompts2({
     hint: "Der Slug Ihres TurboOps-Projekts",
     message: "Projekt-Slug:",
     name: "projectSlug",
@@ -1240,7 +1419,7 @@ var initCommand = new Command3("init").description("Initialize TurboOps project
   }
   logger.newline();
   logger.warning(`Projekt "${projectSlug}" nicht gefunden.`);
-  const { shouldCreate } = await prompts({
+  const { shouldCreate } = await prompts2({
     initial: true,
     message: "M\xF6chten Sie ein neues Projekt anlegen?",
     name: "shouldCreate",
@@ -1258,7 +1437,7 @@ async function setupProject(project) {
   const { data: environments } = await apiClient.getEnvironments(project.id);
   if (!environments || environments.length === 0) {
     logger.newline();
-    const { shouldCreateStage } = await prompts({
+    const { shouldCreateStage } = await prompts2({
       initial: true,
       message: "Das Projekt hat noch keine Stages. M\xF6chten Sie jetzt eine erstellen?",
       name: "shouldCreateStage",
@@ -1268,18 +1447,18 @@ async function setupProject(project) {
       await createFirstStage(project.id, project.slug);
     }
   }
-  const fs3 = await import("fs/promises");
-  const path3 = await import("path");
-  const gitlabCiPath = path3.join(process.cwd(), ".gitlab-ci.yml");
+  const fs4 = await import("fs/promises");
+  const path4 = await import("path");
+  const gitlabCiPath = path4.join(process.cwd(), ".gitlab-ci.yml");
   let hasGitLabPipeline = false;
   try {
-    await fs3.access(gitlabCiPath);
+    await fs4.access(gitlabCiPath);
     hasGitLabPipeline = true;
   } catch {
   }
   if (!hasGitLabPipeline) {
     logger.newline();
-    const { shouldCreatePipeline } = await prompts({
+    const { shouldCreatePipeline } = await prompts2({
       initial: false,
       message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
       name: "shouldCreatePipeline",
@@ -1289,6 +1468,7 @@ async function setupProject(project) {
       await createPipeline(project.id);
     }
   }
+  await offerAiAssistance(project.slug);
   await showFinalSummary(project);
 }
 async function createNewProject(slug) {
@@ -1330,7 +1510,7 @@ async function createNewProject(slug) {
       type: "text"
     }
   );
-  const projectDetails = await prompts(promptQuestions);
+  const projectDetails = await prompts2(promptQuestions);
   if (!projectDetails.name) {
     logger.warning("Projekterstellung abgebrochen");
     addJsonData({ initialized: false, reason: "cancelled" });
@@ -1347,9 +1527,14 @@ async function createNewProject(slug) {
     })
   );
   if (createError || !newProject) {
-    logger.error(`Projekt konnte nicht erstellt werden: ${createError || "Unbekannter Fehler"}`);
+    const errorMsg = createError || "Leere Antwort vom Server";
+    logger.error(`Projekt konnte nicht erstellt werden: ${errorMsg}`);
+    if (process.env.DEBUG) {
+      console.debug("[DEBUG] createError:", createError);
+      console.debug("[DEBUG] newProject:", newProject);
+    }
     addJsonData({
-      error: createError || "Unknown error",
+      error: errorMsg,
       initialized: false,
       reason: "create_failed"
     });
@@ -1358,7 +1543,7 @@ async function createNewProject(slug) {
   logger.success(`Projekt "${newProject.name}" wurde erstellt!`);
   configService.setProject(newProject.slug);
   logger.newline();
-  const { shouldCreateStage } = await prompts({
+  const { shouldCreateStage } = await prompts2({
     initial: true,
     message: "M\xF6chten Sie jetzt die erste Stage anlegen?",
     name: "shouldCreateStage",
@@ -1368,7 +1553,7 @@ async function createNewProject(slug) {
     await createFirstStage(newProject.id, newProject.slug);
   }
   logger.newline();
-  const { shouldCreatePipeline } = await prompts({
+  const { shouldCreatePipeline } = await prompts2({
     initial: true,
     message: "M\xF6chten Sie eine CI/CD Pipeline anlegen?",
     name: "shouldCreatePipeline",
@@ -1437,7 +1622,7 @@ async function createFirstStage(projectId, projectSlug) {
       type: "select"
     });
   }
-  const stageDetails = await prompts(stageQuestions);
+  const stageDetails = await prompts2(stageQuestions);
   if (!stageDetails.name || !stageDetails.slug) {
     logger.warning("Stage-Erstellung abgebrochen");
     return;
@@ -1475,7 +1660,7 @@ async function createPipeline(projectId) {
       type: "select"
     }
   ];
-  const pipelineDetails = await prompts(pipelineQuestions);
+  const pipelineDetails = await prompts2(pipelineQuestions);
   if (!pipelineDetails.pipelineType) {
     logger.warning("Pipeline-Erstellung abgebrochen");
     return;
@@ -1488,18 +1673,18 @@ async function createPipeline(projectId) {
     logger.error(`Pipeline konnte nicht generiert werden: ${error || "Unbekannter Fehler"}`);
     return;
   }
-  const fs3 = await import("fs/promises");
-  const path3 = await import("path");
+  const fs4 = await import("fs/promises");
+  const path4 = await import("path");
   let filePath;
   if (pipelineDetails.pipelineType === "github") {
-    const workflowsDir = path3.join(process.cwd(), ".github", "workflows");
-    await fs3.mkdir(workflowsDir, { recursive: true });
-    filePath = path3.join(workflowsDir, "deploy.yml");
+    const workflowsDir = path4.join(process.cwd(), ".github", "workflows");
+    await fs4.mkdir(workflowsDir, { recursive: true });
+    filePath = path4.join(workflowsDir, "deploy.yml");
   } else {
-    filePath = path3.join(process.cwd(), ".gitlab-ci.yml");
+    filePath = path4.join(process.cwd(), ".gitlab-ci.yml");
   }
   try {
-    await fs3.writeFile(filePath, pipeline.content, "utf-8");
+    await fs4.writeFile(filePath, pipeline.content, "utf-8");
     logger.success(`${pipeline.filename} wurde erstellt!`);
     logger.newline();
     const { data: secrets } = await apiClient.getPipelineSecrets(projectId, pipelineDetails.pipelineType);
@@ -1557,6 +1742,114 @@ async function showFinalSummary(project) {
     "F\xFChren Sie `turbo logs <stage>` aus, um Logs anzuzeigen"
   ]);
 }
+async function offerAiAssistance(projectSlug) {
+  const detection = await detectProjectConfig();
+  if (!detection.hasDockerCompose) {
+    logger.newline();
+    logger.warning("Keine docker-compose.yml gefunden.");
+    logger.info("TurboOps Deployment ben\xF6tigt eine docker-compose.yml auf Root-Ebene.");
+    const { shouldCreateDocker } = await prompts2({
+      type: "confirm",
+      name: "shouldCreateDocker",
+      message: "Docker-Setup mit AI erstellen lassen?",
+      initial: true
+    });
+    if (shouldCreateDocker) {
+      await createDockerSetupWithAI();
+    }
+  }
+  if ((detection.hasGitLabPipeline || detection.hasGitHubPipeline) && !detection.hasTurboOpsInPipeline) {
+    logger.newline();
+    const pipelineType = detection.hasGitLabPipeline ? "GitLab" : "GitHub";
+    const { shouldIntegrate } = await prompts2({
+      type: "confirm",
+      name: "shouldIntegrate",
+      message: `${pipelineType} Pipeline gefunden ohne TurboOps. Mit AI integrieren lassen?`,
+      initial: true
+    });
+    if (shouldIntegrate) {
+      await integratePipelineWithAI(detection, projectSlug);
+    }
+  }
+}
+async function createDockerSetupWithAI() {
+  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!**
+
+Anforderungen:
+1. Erstelle eine "docker-compose.yml" im Projekt-Root
+   - Services f\xFCr alle Komponenten (z.B. api, app, db wenn n\xF6tig)
+   - Verwende build-Direktive mit Pfad zu den Dockerfiles
+   - Health-Checks f\xFCr alle Services
+   - Production-geeignete Konfiguration
+
+2. Erstelle Dockerfiles in den entsprechenden Unterordnern
+   - Multi-stage builds f\xFCr kleine Images
+   - F\xFCr jeden Service ein eigenes Dockerfile (z.B. ./api/Dockerfile, ./app/Dockerfile)
+   - Optimiert f\xFCr Production
+
+3. Erstelle eine ".dockerignore" auf Root-Ebene
+   - node_modules, .git, etc. ausschlie\xDFen
+
+4. Falls Monorepo: Beachte die Projekt-Struktur
+   - Pr\xFCfe ob projects/, packages/, apps/ Ordner existieren
+
+Beispiel docker-compose.yml Struktur:
+\`\`\`yaml
+version: '3.8'
+services:
+  api:
+    build:
+      context: .
+      dockerfile: ./api/Dockerfile
+    ports:
+      - "3000:3000"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+\`\`\`
+
+Erstelle alle notwendigen Dateien.`;
+  const success = await aiToolsService.runWithPrompt(tool, prompt);
+  if (success) {
+    logger.success("Docker-Setup wurde erstellt!");
+  }
+}
+async function integratePipelineWithAI(detection, projectSlug) {
+  const tool = await aiToolsService.selectTool();
+  if (!tool) return;
+  const pipelineType = detection.hasGitLabPipeline ? "GitLab CI" : "GitHub Actions";
+  const pipelineFile = detection.pipelinePath;
+  const prompt = `Integriere TurboOps Deployment in die bestehende ${pipelineType} Pipeline.
+
+Projekt-Slug: ${projectSlug}
+Pipeline-Datei: ${pipelineFile}
+
+Anforderungen:
+1. Die bestehende Pipeline-Struktur beibehalten
+2. Einen neuen Deploy-Job/Step hinzuf\xFCgen der nach dem Build l\xE4uft
+3. TurboOps CLI installieren: npm install -g @turboops/cli
+4. Token setzen: turbo config set token \${TURBOOPS_TOKEN}
+5. Deploy ausf\xFChren: turbo deploy <environment> --image <image-tag> --wait
+
+Die erste Stage braucht --image, weitere Stages k\xF6nnen ohne --image deployen (Promotion).
+
+F\xFCge am Ende einen Kommentar hinzu welche Secrets ben\xF6tigt werden:
+- TURBOOPS_TOKEN: TurboOps Projekt-Token
+
+Modifiziere die Datei "${pipelineFile}" entsprechend.`;
+  const success = await aiToolsService.runWithPrompt(tool, prompt);
+  if (success) {
+    logger.success("Pipeline wurde mit AI aktualisiert!");
+    logger.newline();
+    logger.info("Vergessen Sie nicht, das CI/CD Secret TURBOOPS_TOKEN zu konfigurieren.");
+  }
+}
 
 // src/commands/logs.ts
 import { Command as Command4 } from "commander";
@@ -1825,17 +2118,33 @@ function getStatusColor2(status) {
 
 // src/commands/pipeline.ts
 import { Command as Command6 } from "commander";
-import prompts2 from "prompts";
+import prompts3 from "prompts";
 import chalk7 from "chalk";
-import * as fs2 from "fs/promises";
-import * as path2 from "path";
+import * as fs3 from "fs/promises";
+import * as path3 from "path";
 var pipelineCommand = new Command6("pipeline").description("Manage CI/CD pipeline configuration");
 pipelineCommand.command("generate").description("Generate CI/CD pipeline configuration").option("-t, --type <type>", "Pipeline type (gitlab, github)").option("-f, --force", "Overwrite existing pipeline file").option("-o, --output <path>", "Custom output path").action(async (options) => {
   const { project } = await getCommandContext();
   logger.header("CI/CD Pipeline generieren");
+  const detection = await detectProjectConfig();
+  if (!detection.hasDockerCompose) {
+    logger.warning("Keine docker-compose.yml gefunden.");
+    logger.info("TurboOps Deployment ben\xF6tigt eine docker-compose.yml.");
+    logger.newline();
+    const { shouldCreateDocker } = await prompts3({
+      type: "confirm",
+      name: "shouldCreateDocker",
+      message: "Docker-Setup mit AI erstellen?",
+      initial: true
+    });
+    if (shouldCreateDocker) {
+      await createDockerSetupWithAI2();
+      logger.newline();
+    }
+  }
   let pipelineType = options.type;
   if (!pipelineType) {
-    const { selectedType } = await prompts2({
+    const { selectedType } = await prompts3({
       choices: [
         { title: "GitLab CI/CD", value: "gitlab" },
         { title: "GitHub Actions", value: "github" }
@@ -1858,25 +2167,49 @@ pipelineCommand.command("generate").description("Generate CI/CD pipeline configu
   }
   let outputPath;
   if (options.output) {
-    outputPath = path2.resolve(options.output);
+    outputPath = path3.resolve(options.output);
   } else if (pipelineType === "github") {
-    outputPath = path2.join(process.cwd(), ".github", "workflows", "deploy.yml");
+    outputPath = path3.join(process.cwd(), ".github", "workflows", "deploy.yml");
   } else {
-    outputPath = path2.join(process.cwd(), ".gitlab-ci.yml");
+    outputPath = path3.join(process.cwd(), ".gitlab-ci.yml");
   }
   if (!options.force) {
     try {
-      await fs2.access(outputPath);
-      const { shouldOverwrite } = await prompts2({
-        initial: false,
-        message: `${path2.basename(outputPath)} existiert bereits. \xDCberschreiben?`,
-        name: "shouldOverwrite",
-        type: "confirm"
-      });
-      if (!shouldOverwrite) {
-        logger.info("Pipeline-Generierung abgebrochen");
-        addJsonData({ generated: false, reason: "file_exists" });
-        return;
+      await fs3.access(outputPath);
+      const content = await fs3.readFile(outputPath, "utf-8");
+      const hasTurboOps = content.includes("turbo deploy") || content.includes("@turboops/cli");
+      if (!hasTurboOps) {
+        const { action } = await prompts3({
+          type: "select",
+          name: "action",
+          message: `${path3.basename(outputPath)} existiert bereits ohne TurboOps.`,
+          choices: [
+            { title: "Mit AI integrieren (empfohlen)", value: "ai-integrate" },
+            { title: "\xDCberschreiben", value: "overwrite" },
+            { title: "Abbrechen", value: "cancel" }
+          ]
+        });
+        if (action === "cancel" || !action) {
+          logger.info("Pipeline-Generierung abgebrochen");
+          addJsonData({ generated: false, reason: "cancelled" });
+          return;
+        }
+        if (action === "ai-integrate") {
+          await integratePipelineWithAI2(pipelineType, project.slug, outputPath);
+          return;
+        }
+      } else {
+        const { shouldOverwrite } = await prompts3({
+          initial: false,
+          message: `${path3.basename(outputPath)} existiert bereits mit TurboOps. \xDCberschreiben?`,
+          name: "shouldOverwrite",
+          type: "confirm"
+        });
+        if (!shouldOverwrite) {
+          logger.info("Pipeline-Generierung abgebrochen");
+          addJsonData({ generated: false, reason: "file_exists" });
+          return;
+        }
       }
     } catch {
     }
@@ -1890,13 +2223,13 @@ pipelineCommand.command("generate").description("Generate CI/CD pipeline configu
     addJsonData({ error: error || "Unknown error", generated: false });
     process.exit(13 /* API_ERROR */);
   }
-  const outputDir = path2.dirname(outputPath);
-  await fs2.mkdir(outputDir, { recursive: true });
+  const outputDir = path3.dirname(outputPath);
+  await fs3.mkdir(outputDir, { recursive: true });
   try {
-    await fs2.writeFile(outputPath, pipeline.content, "utf-8");
-    logger.success(`${path2.relative(process.cwd(), outputPath)} wurde erstellt!`);
+    await fs3.writeFile(outputPath, pipeline.content, "utf-8");
+    logger.success(`${path3.relative(process.cwd(), outputPath)} wurde erstellt!`);
     addJsonData({
-      filename: path2.relative(process.cwd(), outputPath),
+      filename: path3.relative(process.cwd(), outputPath),
       generated: true,
       project: project.slug,
       type: pipelineType
@@ -1954,11 +2287,160 @@ async function showSecrets(projectId, pipelineType) {
   logger.info("Projekt-Token k\xF6nnen Sie in der TurboOps Web-UI erstellen:");
   logger.info("Projekt \u2192 Settings \u2192 Tokens \u2192 Neuen Token erstellen");
 }
+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!**
+
+Anforderungen:
+1. Erstelle eine "docker-compose.yml" im Projekt-Root
+   - Services f\xFCr alle Komponenten (z.B. api, app, db wenn n\xF6tig)
+   - Verwende build-Direktive mit Pfad zu den Dockerfiles
+   - Health-Checks f\xFCr alle Services
+   - Production-geeignete Konfiguration
+
+2. Erstelle Dockerfiles in den entsprechenden Unterordnern
+   - Multi-stage builds f\xFCr kleine Images
+   - F\xFCr jeden Service ein eigenes Dockerfile (z.B. ./api/Dockerfile, ./app/Dockerfile)
+   - Optimiert f\xFCr Production
+
+3. Erstelle eine ".dockerignore" auf Root-Ebene
+   - node_modules, .git, etc. ausschlie\xDFen
+
+4. Falls Monorepo: Beachte die Projekt-Struktur
+   - Pr\xFCfe ob projects/, packages/, apps/ Ordner existieren
+
+Erstelle alle notwendigen Dateien.`;
+  const success = await aiToolsService.runWithPrompt(tool, prompt);
+  if (success) {
+    logger.success("Docker-Setup wurde erstellt!");
+  }
+}
+async function integratePipelineWithAI2(pipelineType, projectSlug, pipelinePath) {
+  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}
+
+Anforderungen:
+1. Die bestehende Pipeline-Struktur beibehalten
+2. Einen neuen Deploy-Job/Step hinzuf\xFCgen der nach dem Build l\xE4uft
+3. TurboOps CLI installieren: npm install -g @turboops/cli
+4. Token setzen: turbo config set token \${TURBOOPS_TOKEN}
+5. Deploy ausf\xFChren: turbo deploy <environment> --image <image-tag> --wait
+
+Die erste Stage braucht --image, weitere Stages k\xF6nnen ohne --image deployen (Auto-Promotion).
+
+Secrets die ben\xF6tigt werden:
+- TURBOOPS_TOKEN: TurboOps Projekt-Token
+
+Modifiziere die Datei "${pipelinePath}" entsprechend.`;
+  const success = await aiToolsService.runWithPrompt(tool, prompt);
+  if (success) {
+    logger.success("Pipeline wurde mit AI aktualisiert!");
+    logger.newline();
+    logger.info("Vergessen Sie nicht, das CI/CD Secret TURBOOPS_TOKEN zu konfigurieren.");
+    addJsonData({ generated: true, method: "ai-integration" });
+  } else {
+    addJsonData({ generated: false, reason: "ai_failed" });
+  }
+}
+
+// src/commands/docker.ts
+import { Command as Command7 } 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!**
+
+Anforderungen:
+1. Erstelle eine "docker-compose.yml" im Projekt-Root
+   - Services f\xFCr alle Komponenten (z.B. api, app, db wenn n\xF6tig)
+   - Verwende build-Direktive mit Pfad zu den Dockerfiles
+   - Health-Checks f\xFCr alle Services
+   - Production-geeignete Konfiguration
+
+2. Erstelle Dockerfiles in den entsprechenden Unterordnern
+   - Multi-stage builds f\xFCr kleine Images
+   - F\xFCr jeden Service ein eigenes Dockerfile (z.B. ./api/Dockerfile, ./app/Dockerfile)
+   - Optimiert f\xFCr Production
+
+3. Erstelle eine ".dockerignore" auf Root-Ebene
+   - node_modules, .git, etc. ausschlie\xDFen
+
+4. Falls Monorepo: Beachte die Projekt-Struktur
+   - Pr\xFCfe ob projects/, packages/, apps/ Ordner existieren
+
+Beispiel docker-compose.yml Struktur:
+\`\`\`yaml
+version: '3.8'
+services:
+  api:
+    build:
+      context: .
+      dockerfile: ./api/Dockerfile
+    ports:
+      - "3000:3000"
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+\`\`\`
+
+Erstelle alle notwendigen Dateien.`;
+var dockerCommand = new Command7("docker").description("Manage Docker configuration");
+dockerCommand.command("generate").description("Docker-Setup (docker-compose + Dockerfiles) mit AI erstellen").option("-f, --force", "Bestehende Dateien \xFCberschreiben").action(async (options) => {
+  logger.header("Docker-Setup generieren");
+  const detection = await detectProjectConfig();
+  if (detection.hasDockerCompose && !options.force) {
+    logger.warning("docker-compose.yml existiert bereits.");
+    const { shouldOverwrite } = await prompts4({
+      type: "confirm",
+      name: "shouldOverwrite",
+      message: "M\xF6chten Sie das bestehende Setup \xFCberschreiben?",
+      initial: false
+    });
+    if (!shouldOverwrite) {
+      logger.info("Docker-Setup Generierung abgebrochen");
+      addJsonData({ generated: false, reason: "file_exists" });
+      return;
+    }
+  }
+  const tool = await aiToolsService.selectTool();
+  if (!tool) {
+    addJsonData({ generated: false, reason: "no_ai_tool" });
+    return;
+  }
+  const success = await aiToolsService.runWithPrompt(tool, DOCKER_SETUP_PROMPT);
+  if (success) {
+    logger.success("Docker-Setup wurde erstellt!");
+    logger.newline();
+    logger.info("N\xE4chste Schritte:");
+    logger.list([
+      "Pr\xFCfen Sie die erstellten Dateien",
+      "Passen Sie Umgebungsvariablen an",
+      "Testen Sie mit: docker compose build && docker compose up"
+    ]);
+    addJsonData({ generated: true });
+  } else {
+    logger.warning("Docker-Setup Generierung wurde abgebrochen oder ist fehlgeschlagen.");
+    addJsonData({ generated: false, reason: "ai_failed" });
+  }
+});
 
 // src/index.ts
 var VERSION = getCurrentVersion();
 var shouldCheckUpdate = true;
-var program = new Command7();
+var program = new Command8();
 program.name("turbo").description("TurboCLI - Command line interface for TurboOps deployments").version(VERSION, "-v, --version", "Show version number").option("--project <slug>", "Override project slug").option("--token <token>", "Override API token").option("--json", "Output as JSON").option("--quiet", "Only show errors").option("--verbose", "Show debug output").option("--no-update-check", "Skip version check");
 program.hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
@@ -1997,6 +2479,7 @@ program.addCommand(configCommand);
 program.addCommand(logsCommand);
 program.addCommand(deployCommand);
 program.addCommand(pipelineCommand);
+program.addCommand(dockerCommand);
 program.command("self-update").description("Update TurboCLI to the latest version").action(async () => {
   logger.info("Checking for updates...");
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turboops/cli",
-  "version": "1.0.0-dev.584",
+  "version": "1.0.0-dev.586",
   "description": "TurboCLI - Command line interface for TurboOps deployments",
   "author": "lenne.tech GmbH",
   "license": "MIT",