appiq-solution 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,162 @@
+# 🚀 Appiq Solution - Super Einfache KI-Agent Installation
+
+*Built with ❤️ based on the amazing Bmad-Method*
+
+## ⚡ One-Command Installation
+
+```bash
+npx appiq-solution install
+```
+
+**Das war's!** 🎯 Kein komplizierter Setup mehr.
+
+## 🎮 Was passiert automatisch?
+
+### 1. **🔍 Intelligente Projekt-Erkennung**
+- ✅ **Automatisch erkennt:** Greenfield vs. Brownfield
+- ✅ **Analysiert:** Bestehenden Code, Dokumentation, Tech-Stack
+- ✅ **Empfiehlt:** Optimalen Workflow für Ihr Projekt
+
+### 2. **🛠️ IDE-Integration (One-Click)**
+- ✅ **Cursor** → `.cursor/rules/` mit `.mdc` Dateien
+- ✅ **Claude Code** → `.claude/commands/Appiq/` mit `.md` Dateien
+- ✅ **Windsurf** → `.windsurf/rules/` mit `.md` Dateien
+- ✅ **VS Code + Cline** → `.clinerules/` mit `.md` Dateien
+
+### 3. **📁 Automatische Datei-Organisation**
+
+**Neue Projekte (Greenfield):**
+```
+your-project/
+├── docs/
+│   ├── prd.md              ← PRD wird hier erstellt
+│   ├── architecture.md     ← Architektur wird hier erstellt
+│   └── stories/            ← User Stories werden hier erstellt
+├── appiq-solution/
+│   ├── agents/             ← Optimierte KI-Agents
+│   └── commands/           ← One-Click Kommandos
+└── .cursor/rules/          ← IDE-spezifische Integration
+```
+
+**Bestehende Projekte (Brownfield):**
+```
+your-existing-project/
+├── docs/                   ← Bestehende Docs werden gescannt
+│   ├── prd.md             ← PRD falls vorhanden, sonst erstellt
+│   └── architecture.md     ← Architektur-Review
+├── appiq-solution/         ← Neue Appiq Solution Installation
+└── .cursor/rules/          ← IDE Integration (nicht-invasiv)
+```
+
+## 🚀 Super Einfache Nutzung
+
+### Schritt 1: Installation
+```bash
+npx appiq-solution install
+```
+
+### Schritt 2: Agent laden (Cursor Beispiel)
+```bash
+# Appiq Launcher ist bereits in .cursor/rules/smart-launcher.mdc
+# Einfach in Cursor sagen: "Agiere als Appiq Launcher"
+```
+
+### Schritt 3: One-Command Start
+```bash
+# Für NEUE Projekte:
+/start
+
+# Für BESTEHENDE Projekte:
+/analyze
+```
+
+**Das war's!** 🎉 Das System führt Sie automatisch durch alles.
+
+## 🎯 One-Click Workflows
+
+### Greenfield (Neue Projekte)
+```
+/start → PRD → Architektur → Stories → Code → Tests
+```
+
+### Brownfield (Bestehende Projekte)  
+```
+/analyze → Review → Neue Features → Integration → Tests
+```
+
+## 🤖 Optimierte Agents
+
+| Agent | Kommando | Funktion |
+|-------|----------|----------|
+| **Appiq Launcher** | `/start` | Intelligenter Projekt-Start |
+| **Project Manager** | `/prd` | PRD & Dokumentation |
+| **System Architect** | `/architecture` | Technische Architektur |
+| **Story Master** | `/story` | User Stories & Sprints |
+| **Senior Developer** | `/code` | Code Implementation |
+| **QA Expert** | `/test` | Testing & Validierung |
+
+## 💡 Warum Appiq Solution?
+
+### ❌ **Vorher (Kompliziert):**
+- ✗ Komplexer Web-Client Setup
+- ✗ Unklare Anweisungen
+- ✗ Viele manuelle Schritte
+- ✗ Verwirrende Datei-Organisation
+
+### ✅ **Jetzt (Super Einfach):**
+- ✅ **Ein Kommando:** `npx appiq-solution install`
+- ✅ **Automatische Erkennung:** Greenfield/Brownfield
+- ✅ **Klare Anweisungen:** Wo gehört was hin
+- ✅ **One-Click Workflows:** Alles automatisiert
+
+## 🆘 Hilfe & Support
+
+### Quick Commands
+- **`/help`** - Alle verfügbaren Kommandos
+- **`/status`** - Aktueller Projekt-Status
+- **`/next`** - Nächster Schritt
+
+### Troubleshooting
+```bash
+# Installation prüfen
+ls appiq-solution/
+
+# Agent-Liste anzeigen  
+ls appiq-solution/agents/
+
+# IDE-Integration prüfen
+ls .cursor/rules/     # für Cursor
+ls .claude/commands/  # für Claude Code
+```
+
+## 🎮 Beispiel-Session
+
+```bash
+# Installation
+$ npx appiq-solution install
+🔍 Projekt-Analyse... → Brownfield erkannt
+🛠️ IDE: Cursor ausgewählt  
+✅ Installation abgeschlossen!
+
+# In Cursor IDE
+> "Agiere als Appiq Launcher"
+> /analyze
+
+🔍 Analyzing existing project...
+✅ Found: package.json (Node.js project)
+✅ Found: src/ directory with React components
+✅ Missing: PRD documentation
+📋 Recommendation: Create PRD first, then add new features
+
+> /prd
+
+📝 Creating PRD for existing React project...
+✅ PRD created: docs/prd.md
+🎯 Next: /architecture to review technical setup
+```
+
+**So einfach ist das!** 🚀
+
+---
+*Appiq Solution - Entwicklung war nie einfacher.*
+*Built with ❤️ based on Bmad-Method*

package/appiq-installer.js

@@ -0,0 +1,833 @@
+#!/usr/bin/env node
+
+/**
+ * Appiq Solution Smart Installer
+ * 
+ * Super einfache Installation mit One-Click Workflows
+ * Usage: npx appiq-solution install
+ * 
+ * Built with ❤️ based on the amazing Bmad-Method
+ * Credits: https://github.com/Viktor-Hermann/APPIQ-METHOD
+ */
+
+const fs = require('fs');
+const path = require('path');
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+class AppiqSolutionInstaller {
+  constructor() {
+    this.projectRoot = process.cwd();
+    this.appiqPath = path.join(this.projectRoot, "appiq-solution");
+    this.config = {
+      version: "1.0.0",
+      projectType: null, // 'greenfield' or 'brownfield'
+      techStack: {},
+      selectedIDEs: [],
+      projectName: null,
+      projectIdea: null,
+      targetUsers: null,
+      projectPlan: null,
+      planApproved: false,
+    };
+  }
+
+  async install() {
+    console.log(chalk.bold.cyan("🚀 Appiq Solution Smart Installer v1.0.0"));
+    console.log(chalk.cyan("============================================"));
+    console.log(chalk.dim("Built with ❤️  based on Bmad-Method"));
+    console.log(chalk.dim("https://github.com/Viktor-Hermann/APPIQ-METHOD\n"));
+
+    try {
+      // Phase 1: Projekt-Typ Detection
+      await this.detectProjectType();
+      
+        // Phase 2: Projektidee erfassen
+        await this.collectProjectIdea();
+
+        // Phase 3: IDE Selection (MULTISELECT)
+      await this.selectIDE();
+      
+        // Phase 4: Projektplan erstellen
+        await this.createProjectPlan();
+
+        // Phase 5: Plan-Freigabe
+        await this.approvePlan();
+
+                // Phase 6: Installation
+      await this.performInstallation();
+      
+        // Phase 7: One-Click Setup
+      await this.setupOneClickWorkflows();
+      
+        // Phase 8: Agent-Orchestrierung vorbereiten
+        await this.setupAgentOrchestration();
+
+        // Phase 9: Simple Instructions
+      await this.showSimpleInstructions();
+    } catch (error) {
+      console.error(chalk.red("❌ Installation failed:"), error.message);
+      process.exit(1);
+    }
+  }
+
+  async detectProjectType() {
+    console.log(chalk.yellow("🔍 Projekt-Analyse..."));
+    
+    // Auto-Detection
+    const hasPackageJson = fs.existsSync(
+      path.join(this.projectRoot, "package.json")
+    );
+    const hasPubspec = fs.existsSync(
+      path.join(this.projectRoot, "pubspec.yaml")
+    );
+    const hasExistingCode = this.hasExistingSourceCode();
+    const hasDocumentation = this.hasExistingDocumentation();
+    
+    let suggestedType = "greenfield";
+    let reason = "Neues Projekt erkannt";
+    
+    if (hasExistingCode || hasDocumentation) {
+      suggestedType = "brownfield";
+      reason = "Existierenden Code/Dokumentation gefunden";
+    }
+    
+    console.log(chalk.gray(`💡 Analyse: ${reason}`));
+    console.log(
+      chalk.gray(
+        `📊 Empfehlung: ${
+          suggestedType === "greenfield"
+            ? "Greenfield (Neues Projekt)"
+            : "Brownfield (Bestehendes Projekt)"
+        }`
+      )
+    );
+    
+    // User Confirmation
+    const { projectType } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "projectType",
+        message: "🎯 Welcher Projekt-Typ ist das?",
+        choices: [
+          {
+            name: `✨ Greenfield - Neues Projekt (Empfohlen: ${
+              suggestedType === "greenfield" ? "✅" : "❌"
+            })`,
+            value: "greenfield",
+            short: "Greenfield",
+          },
+          {
+            name: `🔧 Brownfield - Bestehendes Projekt (Empfohlen: ${
+              suggestedType === "brownfield" ? "✅" : "❌"
+            })`,
+            value: "brownfield",
+            short: "Brownfield",
+          },
+        ],
+        default: suggestedType,
+      },
+    ]);
+    
+    this.config.projectType = projectType;
+    console.log(
+      chalk.green(
+        `✅ Projekt-Typ: ${
+          projectType === "greenfield"
+            ? "Greenfield (Neu)"
+            : "Brownfield (Bestehend)"
+        }\n`
+      )
+    );
+  }
+
+  async selectIDE() {
+    console.log(chalk.yellow("🛠️ IDE Auswahl"));
+    console.log(chalk.bold.yellow.bgRed(" ⚠️  MULTISELECT: Verwenden Sie SPACEBAR zum Auswählen mehrerer IDEs! "));
+    console.log(chalk.gray("Wählen Sie ALLE IDEs aus, die Sie nutzen:\n"));
+
+    const { ides } = await inquirer.prompt([
+      {
+        type: "checkbox",
+        name: "ides",
+        message: "🎯 Welche IDEs nutzen Sie? (SPACEBAR = auswählen, ENTER = bestätigen)",
+        choices: [
+          { name: "🔵 Cursor", value: "cursor" },
+          { name: "🟣 Claude Code CLI", value: "claude-code" },
+          { name: "🟢 Windsurf", value: "windsurf" },
+          { name: "🔶 VS Code + Cline", value: "cline" },
+          { name: "🟠 Trae", value: "trae" },
+          { name: "🔴 Roo Code", value: "roo" },
+          { name: "🟪 Gemini CLI", value: "gemini" },
+          { name: "⚫ GitHub Copilot", value: "github-copilot" },
+        ],
+        validate: (input) => {
+          if (input.length === 0) {
+            return "Bitte wählen Sie mindestens eine IDE aus!";
+          }
+          return true;
+        },
+      },
+    ]);
+
+    this.config.selectedIDEs = ides;
+    const ideNames = ides.map(ide => this.getIDEName(ide)).join(", ");
+    console.log(chalk.green(`✅ IDEs: ${ideNames}\n`));
+  }
+
+  async collectProjectIdea() {
+    console.log(chalk.yellow("💡 Projektidee erfassen"));
+    console.log(chalk.gray("Beschreiben Sie Ihr Projekt-Vorhaben:\n"));
+
+    const { projectIdea, projectName, targetUsers } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "projectName",
+        message: "🏷️ Wie soll Ihr Projekt heißen?",
+        validate: (input) => input.length > 0 ? true : "Bitte geben Sie einen Projektnamen ein!"
+      },
+      {
+        type: "editor",
+        name: "projectIdea",
+        message: "💡 Beschreiben Sie Ihre Projektidee (detailliert):",
+        validate: (input) => input.length > 10 ? true : "Bitte beschreiben Sie Ihr Projekt ausführlicher!"
+      },
+      {
+        type: "input",
+        name: "targetUsers",
+        message: "👥 Wer sind Ihre Zielgruppen/User?",
+        validate: (input) => input.length > 0 ? true : "Bitte beschreiben Sie Ihre Zielgruppe!"
+      }
+    ]);
+
+    this.config.projectName = projectName;
+    this.config.projectIdea = projectIdea;
+    this.config.targetUsers = targetUsers;
+
+    console.log(chalk.green(`✅ Projektidee erfasst: "${projectName}"\n`));
+  }
+
+  async createProjectPlan() {
+    console.log(chalk.yellow("📋 Projektplan wird erstellt..."));
+    console.log(chalk.gray("Basierend auf Ihrer Idee und dem Projekt-Typ\n"));
+
+    // Hier würde normalerweise die team-fullstack.yaml verwendet
+    const plan = this.generateProjectPlan();
+    this.config.projectPlan = plan;
+
+    console.log(chalk.cyan("📋 Ihr Projektplan:"));
+    console.log(chalk.white("─".repeat(50)));
+    console.log(plan);
+    console.log(chalk.white("─".repeat(50) + "\n"));
+  }
+
+  async approvePlan() {
+    const { approved, changes } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "approved",
+        message: "✅ Sind Sie mit diesem Plan zufrieden?",
+        default: true
+      },
+      {
+        type: "input",
+        name: "changes",
+        message: "📝 Welche Änderungen möchten Sie? (oder ENTER für keine Änderungen)",
+        when: (answers) => !answers.approved
+      }
+    ]);
+
+    if (!approved && changes) {
+      console.log(chalk.yellow("📝 Plan wird angepasst..."));
+      this.config.planChanges = changes;
+      // Hier würde Plan angepasst werden
+      console.log(chalk.green("✅ Plan wurde angepasst!\n"));
+    } else {
+      console.log(chalk.green("✅ Plan freigegeben - Entwicklung kann starten!\n"));
+    }
+
+    this.config.planApproved = true;
+  }
+
+  generateProjectPlan() {
+    const { projectType, projectName, projectIdea, targetUsers } = this.config;
+    
+    return `🎯 PROJEKTPLAN: ${projectName}
+
+📊 PROJEKT-TYP: ${projectType === 'greenfield' ? 'Greenfield (Neues Projekt)' : 'Brownfield (Bestehendes Projekt)'}
+👥 ZIELGRUPPE: ${targetUsers}
+
+💡 PROJEKTIDEE:
+${projectIdea}
+
+🚀 ENTWICKLUNGS-PIPELINE:
+${projectType === 'greenfield' ? `
+1. 📋 PO (Product Owner) → PRD erstellen
+2. 🏗️ Architect → System-Architektur designen  
+3. 🎨 UX Expert → UI/UX Design
+4. 📝 Story Master → User Stories aufbrechen
+5. 💻 Developer → Features implementieren
+6. ✅ QA Expert → Testing & Validierung
+7. 📊 SM (Scrum Master) → Sprint-Koordination
+` : `
+1. 📋 PO → Bestehende Dokumentation analysieren
+2. 🏗️ Architect → Architektur-Review
+3. 📝 Story Master → Neue Features planen
+4. 💻 Developer → Features in bestehende Basis integrieren
+5. ✅ QA Expert → Regression Testing
+6. 📊 SM → Change Management
+`}
+
+🎮 ONE-CLICK BEFEHLE:
+- /start → Gesamten Workflow starten
+- /plan → Detailplanung
+- /develop → Entwicklung beginnen
+- /review → Code Review
+- /deploy → Deployment vorbereiten`;
+  }
+
+  async setupAgentOrchestration() {
+    console.log(chalk.yellow("🎭 Agent-Orchestrierung vorbereiten..."));
+    
+    // Team-Fullstack.yaml Integration
+    const orchestrationConfig = {
+      agents: ['po', 'architect', 'ux-expert', 'story-master', 'developer', 'qa-expert', 'sm'],
+      workflows: this.config.projectType === 'greenfield' ? 
+        ['greenfield-fullstack.yaml', 'greenfield-ui.yaml', 'greenfield-service.yaml'] :
+        ['brownfield-fullstack.yaml', 'brownfield-ui.yaml', 'brownfield-service.yaml'],
+      planApproved: this.config.planApproved
+    };
+
+    // Orchestrierung-Datei erstellen
+    const orchestrationPath = path.join(this.appiqPath, 'orchestration.yaml');
+    fs.writeFileSync(orchestrationPath, this.generateOrchestrationConfig(orchestrationConfig));
+
+    console.log(chalk.green("✅ Agent-Orchestrierung vorbereitet!\n"));
+  }
+
+  generateOrchestrationConfig(config) {
+    return `# Appiq Solution Agent Orchestration
+# Built with ❤️ based on Bmad-Method
+
+project:
+  name: ${this.config.projectName}
+  type: ${this.config.projectType}
+  plan_approved: ${this.config.planApproved}
+
+agents:
+${config.agents.map(agent => `  - ${agent}`).join('\n')}
+
+workflows:
+${config.workflows.map(workflow => `  - ${workflow}`).join('\n')}
+
+execution_order:
+  1: "po → PRD & Requirements"
+  2: "architect → System Design"  
+  3: "ux-expert → UI/UX Design"
+  4: "story-master → User Stories"
+  5: "developer → Implementation"
+  6: "qa-expert → Testing"
+  7: "sm → Sprint Management"
+
+ides:
+${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
+`;
+  }
+
+  async performInstallation() {
+    console.log(chalk.yellow("📦 Installation läuft..."));
+    
+    // Create appiq-solution directory
+    if (!fs.existsSync(this.appiqPath)) {
+      fs.mkdirSync(this.appiqPath, { recursive: true });
+    }
+    
+    // Install optimized agents
+    await this.installOptimizedAgents();
+    
+    // Install project-specific configs
+    await this.installProjectConfig();
+    
+    // Setup IDE integration
+    await this.setupIDEIntegration();
+    
+    console.log(chalk.green("✅ Installation abgeschlossen!\n"));
+  }
+
+  async installOptimizedAgents() {
+    console.log(chalk.gray("  📄 Optimierte Agents installieren..."));
+    
+    const agentsDir = path.join(this.appiqPath, "agents");
+    if (!fs.existsSync(agentsDir)) {
+      fs.mkdirSync(agentsDir, { recursive: true });
+    }
+    
+    // Core optimized agents
+    const agents = [
+      "smart-launcher",
+      "project-manager",
+      "architect",
+      "story-master",
+      "developer",
+      "qa-expert",
+    ];
+    
+    for (const agent of agents) {
+      await this.createOptimizedAgent(agent);
+    }
+  }
+
+  async createOptimizedAgent(agentName) {
+    const agentContent = this.generateOptimizedAgentContent(agentName);
+    const filePath = path.join(this.appiqPath, "agents", `${agentName}.md`);
+    fs.writeFileSync(filePath, agentContent);
+  }
+
+  generateOptimizedAgentContent(agentName) {
+    const agentConfigs = {
+      "smart-launcher": {
+        name: "Appiq Launcher",
+        role: "Intelligenter Projekt-Starter",
+        commands: ["/start", "/quick-setup", "/help"],
+        description:
+          "Startet automatisch den optimalen Workflow basierend auf Ihrem Projekt-Typ",
+      },
+      "project-manager": {
+        name: "Project Manager",
+        role: "PRD & Projekt-Planung",
+        commands: ["/prd", "/plan", "/epic"],
+        description: "Erstellt PRD und Projekt-Dokumentation",
+      },
+      architect: {
+        name: "System Architect",
+        role: "Technische Architektur",
+        commands: ["/architecture", "/tech-stack", "/design"],
+        description: "Entwickelt System-Architektur und Tech-Stack",
+      },
+      "story-master": {
+        name: "Story Master",
+        role: "User Stories & Sprint Planning",
+        commands: ["/story", "/sprint", "/tasks"],
+        description: "Erstellt User Stories und Sprint-Planung",
+      },
+      developer: {
+        name: "Senior Developer",
+        role: "Code Implementation",
+        commands: ["/code", "/implement", "/fix"],
+        description: "Implementiert Features und behebt Bugs",
+      },
+      "qa-expert": {
+        name: "QA Expert",
+        role: "Testing & Qualität",
+        commands: ["/test", "/review", "/validate"],
+        description: "Führt Tests durch und validiert Code-Qualität",
+      },
+    };
+
+    const config = agentConfigs[agentName];
+    
+    return `# ${config.name}
+
+## 🎯 Rolle
+${config.role}
+
+## 📋 Verfügbare Kommandos
+${config.commands
+  .map((cmd) => `- **${cmd}** - ${config.description}`)
+  .join("\n")}
+
+## 🚀 One-Click Workflows
+
+### Für ${
+      this.config.projectType === "greenfield" ? "NEUE" : "BESTEHENDE"
+    } Projekte:
+
+${
+  this.config.projectType === "greenfield"
+    ? this.generateGreenfieldWorkflow(config)
+    : this.generateBrownfieldWorkflow(config)
+}
+
+## 🎮 Einfache Nutzung
+
+1. **Laden Sie diesen Agent in Ihre IDE**
+2. **Sagen Sie:** "Agiere als ${config.name}"
+3. **Verwenden Sie:** ${config.commands[0]} für Quick-Start
+
+---
+*Automatisch optimiert für ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}*
+*Powered by Appiq - Based on Bmad-Method*
+`;
+  }
+
+  generateGreenfieldWorkflow(config) {
+    const workflows = {
+      "Appiq Launcher": `
+**🚀 Schnell-Start für neues Projekt:**
+1. \`/start\` - Automatische Projekt-Analyse
+2. Erstellt automatisch: PRD-Vorlage, Architektur-Basis, erste Stories
+3. **Wo alles hingehört:** Alle Dateien werden automatisch in \`docs/\` erstellt`,
+
+      "Project Manager": `
+**📋 PRD Erstellung:**
+1. \`/prd\` - Startet PRD-Assistent
+2. **Datei wird erstellt:** \`docs/prd.md\`
+3. **Nächster Schritt:** Architect für Architektur`,
+
+      "System Architect": `
+**🏗️ Architektur erstellen:**
+1. \`/architecture\` - Basierend auf PRD
+2. **Datei wird erstellt:** \`docs/architecture.md\`
+3. **Nächster Schritt:** Story Master für erste Stories`,
+
+      "Story Master": `
+**📝 Erste Stories:**
+1. \`/story\` - Erstellt erste User Story
+2. **Datei wird erstellt:** \`docs/stories/story-001.md\`
+3. **Nächster Schritt:** Developer für Implementation`,
+
+      "Senior Developer": `
+**💻 Implementation:**
+1. \`/implement\` - Implementiert aktuelle Story
+2. **Erstellt/bearbeitet:** Entsprechende Code-Dateien
+3. **Nächster Schritt:** QA Expert für Review`,
+
+      "QA Expert": `
+**✅ Testing & Review:**
+1. \`/review\` - Reviewed aktuellen Code
+2. **Erstellt:** Test-Dateien und Reports
+3. **Nächster Schritt:** Zurück zu Story Master für nächste Story`,
+    };
+
+    return workflows[config.name] || "Standard Greenfield Workflow";
+  }
+
+  generateBrownfieldWorkflow(config) {
+    const workflows = {
+      "Appiq Launcher": `
+**🔧 Schnell-Start für bestehendes Projekt:**
+1. \`/analyze\` - Analysiert bestehendes Projekt
+2. **Findet:** Existierende Docs, Code-Struktur, Tech-Stack
+3. **Erstellt:** Angepasste Workflows für Ihr Projekt`,
+
+      "Project Manager": `
+**📋 Bestehende Dokumentation:**
+1. \`/analyze-docs\` - Scannt bestehende Dokumentation
+2. **Legt PRD ab in:** \`docs/prd.md\` (falls nicht vorhanden)
+3. **Nächster Schritt:** Architect für Architektur-Review`,
+
+      "System Architect": `
+**🏗️ Architektur-Review:**
+1. \`/review-architecture\` - Analysiert bestehende Struktur
+2. **Erstellt/updated:** \`docs/architecture.md\`
+3. **Nächster Schritt:** Story Master für neue Features`,
+
+      "Story Master": `
+**📝 Feature Stories:**
+1. \`/new-feature\` - Neue Story für bestehendes Projekt
+2. **Datei wird erstellt:** \`docs/stories/feature-XXX.md\`
+3. **Berücksichtigt:** Bestehende Code-Basis`,
+
+      "Senior Developer": `
+**💻 Feature Implementation:**
+1. \`/add-feature\` - Implementiert in bestehendem Code
+2. **Bearbeitet:** Bestehende Dateien sicher
+3. **Erstellt:** Neue Dateien wo nötig`,
+
+      "QA Expert": `
+**✅ Regression Testing:**
+1. \`/regression-test\` - Testet neue Features
+2. **Validiert:** Keine Breaking Changes
+3. **Erstellt:** Test-Reports für bestehende + neue Features`,
+    };
+
+    return workflows[config.name] || "Standard Brownfield Workflow";
+  }
+
+  async setupOneClickWorkflows() {
+    console.log(chalk.yellow("⚡ One-Click Workflows einrichten..."));
+    
+    // Create quick commands
+    const commandsDir = path.join(this.appiqPath, "commands");
+    if (!fs.existsSync(commandsDir)) {
+      fs.mkdirSync(commandsDir, { recursive: true });
+    }
+    
+    // Project-type specific quick starts
+    const quickStartContent = this.generateQuickStartScript();
+    fs.writeFileSync(
+      path.join(commandsDir, "quick-start.md"),
+      quickStartContent
+    );
+    
+    console.log(chalk.green("✅ One-Click Workflows bereit!\n"));
+  }
+
+  generateQuickStartScript() {
+    return `# 🚀 Appiq Solution Quick Start
+
+## Für ${
+      this.config.projectType === "greenfield" ? "NEUE" : "BESTEHENDE"
+    } Projekte
+
+### ⚡ One-Command Start:
+
+\`\`\`bash
+# In Ihrer IDE, kopieren Sie einfach:
+${
+  this.config.projectType === "greenfield"
+    ? "/start new-project"
+    : "/analyze existing-project"
+}
+\`\`\`
+
+### 📁 Wo gehört was hin?
+
+${
+  this.config.projectType === "greenfield"
+    ? `
+**NEUE PROJEKTE:**
+- ✅ **PRD:** \`docs/prd.md\` (wird automatisch erstellt)
+- ✅ **Architektur:** \`docs/architecture.md\` (wird automatisch erstellt)  
+- ✅ **Stories:** \`docs/stories/\` (wird automatisch erstellt)
+- ✅ **Code:** Ihr gewähltes Projekt-Layout
+
+*Erstellt mit Appiq Solution - Basierend auf Bmad-Method*
+`
+    : `
+**BESTEHENDE PROJEKTE:**
+- ✅ **PRD:** Legen Sie bestehende PRD in \`docs/prd.md\`
+- ✅ **Architektur:** Bestehende Architektur in \`docs/architecture.md\`
+- ✅ **Stories:** Neue Features in \`docs/stories/\`
+- ✅ **Code:** Arbeitet mit Ihrer bestehenden Struktur
+`
+}
+
+### 🎯 3-Schritt Erfolgsformel:
+
+1. **Agent laden** → Agent-Datei in IDE kopieren
+2. **Kommando ausführen** → \`${
+      this.config.projectType === "greenfield" ? "/start" : "/analyze"
+    }\`
+3. **Folgen Sie den automatischen Anweisungen** → System führt Sie durch alles
+
+### 🆘 Hilfe:
+
+- **\`/help\`** - Zeigt alle verfügbaren Kommandos
+- **\`/status\`** - Aktueller Projekt-Status
+- **\`/next\`** - Was ist der nächste Schritt?
+
+---
+*Optimiert für ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')} - ${new Date().toLocaleDateString("de-DE")}*
+*Powered by Appiq Solution - Built with ❤️  based on Bmad-Method*
+`;
+  }
+
+  async setupIDEIntegration() {
+    if (this.config.selectedIDEs.includes("manual") && this.config.selectedIDEs.length === 1) return;
+
+    console.log(chalk.gray("  🔧 Mehrere IDE-Integrationen..."));
+
+    for (const ide of this.config.selectedIDEs) {
+      if (ide === "manual") continue;
+      
+      console.log(chalk.gray(`    📝 ${this.getIDEName(ide)} wird konfiguriert...`));
+      
+      const ideConfig = this.getIDEConfig(ide);
+    const ideDir = path.join(this.projectRoot, ideConfig.dir);
+    
+    if (!fs.existsSync(ideDir)) {
+      fs.mkdirSync(ideDir, { recursive: true });
+    }
+    
+    // Copy agents to IDE-specific format
+      const agentsPath = path.join(this.appiqPath, "agents");
+    const agents = fs.readdirSync(agentsPath);
+    
+    for (const agent of agents) {
+      const sourcePath = path.join(agentsPath, agent);
+        const targetPath = path.join(
+          ideDir,
+          agent.replace(".md", ideConfig.suffix)
+        );
+      fs.copyFileSync(sourcePath, targetPath);
+      }
+      
+      console.log(chalk.green(`    ✅ ${this.getIDEName(ide)} konfiguriert`));
+    }
+    
+    console.log(chalk.green("  ✅ Alle IDE-Integrationen abgeschlossen!"));
+  }
+
+  getIDEConfig(ide) {
+    const configs = {
+      cursor: { dir: ".cursor/rules", suffix: ".mdc" },
+      "claude-code": { dir: ".claude/commands/Appiq", suffix: ".md" },
+      windsurf: { dir: ".windsurf/rules", suffix: ".md" },
+      cline: { dir: ".clinerules", suffix: ".md" },
+      trae: { dir: ".trae/rules", suffix: ".md" },
+      roo: { dir: ".roo/agents", suffix: ".md" },
+      gemini: { dir: ".gemini/commands", suffix: ".md" },
+      "github-copilot": { dir: ".github/copilot", suffix: ".md" },
+    };
+    return configs[ide] || { dir: ".appiq-solution", suffix: ".md" };
+  }
+
+  getIDEName(ide) {
+    const names = {
+      cursor: "Cursor",
+      "claude-code": "Claude Code CLI",
+      windsurf: "Windsurf",
+      cline: "VS Code + Cline",
+      trae: "Trae",
+      roo: "Roo Code",
+      gemini: "Gemini CLI",
+      "github-copilot": "GitHub Copilot",
+      manual: "Manuell",
+    };
+    return names[ide] || ide;
+  }
+
+  async showSimpleInstructions() {
+    console.log(chalk.bold.green("🎉 Appiq Installation Erfolgreich!\n"));
+    console.log(chalk.dim("Built with ❤️  based on the amazing Bmad-Method"));
+    console.log(chalk.dim("https://github.com/Viktor-Hermann/APPIQ-METHOD\n"));
+
+    console.log(chalk.cyan("📋 Nächste Schritte (Super einfach):"));
+    console.log(chalk.white("════════════════════════════════════\n"));
+
+    if (this.config.selectedIDEs.length > 0 && !this.config.selectedIDEs.includes("manual")) {
+      console.log(
+        chalk.yellow(`1. Ihre IDEs öffnen: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}`)
+      );
+      console.log(chalk.gray(`   → Agents sind bereits in allen IDEs installiert!\n`));
+    }
+
+    console.log(chalk.yellow("2. Appiq Launcher laden:"));
+    console.log(
+      chalk.white(
+        `   → Kopieren Sie: ${chalk.bold(
+          "appiq-solution/agents/smart-launcher.md"
+        )}`
+      )
+    );
+    console.log(chalk.gray(`   → In Ihre IDE einfügen\n`));
+    
+    console.log(chalk.yellow("3. Sagen Sie Ihrer IDE:"));
+    console.log(
+      chalk.white(`   → ${chalk.bold('"Agiere als Appiq Launcher"')}\n`)
+    );
+
+    console.log(chalk.yellow("4. One-Command Start:"));
+    console.log(
+      chalk.white(
+        chalk.bold(
+          `   → ${
+            this.config.projectType === "greenfield" ? "/start" : "/analyze"
+          }`
+        )
+      )
+    );
+    console.log(
+      chalk.gray(`   → Das System führt Sie automatisch durch alles!\n`)
+    );
+
+    console.log(chalk.cyan("🎯 Das war's! Kein komplizierter Setup mehr."));
+    console.log(chalk.green("🚀 Viel Erfolg mit Appiq!\n"));
+    
+    // Quick reference
+    console.log(chalk.dim("━".repeat(50)));
+    console.log(chalk.dim("📁 Quick Reference:"));
+    console.log(chalk.dim(`   • Agents: appiq-solution/agents/`));
+    console.log(
+      chalk.dim(`   • Quick Start: appiq-solution/commands/quick-start.md`)
+    );
+    console.log(chalk.dim(`   • Projekt-Typ: ${this.config.projectType}`));
+    console.log(
+      chalk.dim(`   • IDEs: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}`)
+    );
+  }
+
+  // Helper methods
+  hasExistingSourceCode() {
+    const sourceDirs = ["src", "lib", "app", "components", "pages"];
+    return sourceDirs.some(
+      (dir) =>
+      fs.existsSync(path.join(this.projectRoot, dir)) && 
+      fs.readdirSync(path.join(this.projectRoot, dir)).length > 0
+    );
+  }
+
+  hasExistingDocumentation() {
+    const docFiles = ["README.md", "docs", "documentation"];
+    return docFiles.some((file) =>
+      fs.existsSync(path.join(this.projectRoot, file))
+    );
+  }
+
+  async installProjectConfig() {
+    const configContent = this.generateProjectConfig();
+    fs.writeFileSync(
+      path.join(this.appiqPath, "project-config.yaml"),
+      configContent
+    );
+  }
+
+  generateProjectConfig() {
+    return `# Appiq Solution Project Configuration
+# Built with ❤️  based on Bmad-Method
+version: "1.0.0"
+project:
+  type: ${this.config.projectType}
+  created: ${new Date().toISOString()}
+  name: ${this.config.projectName || 'Unbenanntes Projekt'}
+  plan_approved: ${this.config.planApproved}
+
+# Wo die wichtigen Dateien liegen
+paths:
+  prd: "docs/prd.md"
+  architecture: "docs/architecture.md" 
+  stories: "docs/stories/"
+  agents: "appiq-solution/agents/"
+  orchestration: "appiq-solution/orchestration.yaml"
+
+# One-Click Workflows
+workflows:
+  ${this.config.projectType === "greenfield" ? "greenfield" : "brownfield"}:
+    start_command: "${
+      this.config.projectType === "greenfield" ? "/start" : "/analyze"
+    }"
+    agents_sequence: 
+      - smart-launcher
+      - project-manager
+      - architect
+      - story-master
+      - developer
+      - qa-expert
+
+# IDE Integration (Mehrere IDEs)
+ides:
+${this.config.selectedIDEs.map(ide => `  - name: ${this.getIDEName(ide)}
+    config_path: ${this.getIDEConfig(ide).dir}
+    file_format: ${this.getIDEConfig(ide).suffix}`).join('\n')}
+`;
+  }
+}
+
+// Run installer if called directly  
+if (require.main === module) {
+  // Check if 'install' command is provided
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args[0] === "install") {
+    const installer = new AppiqSolutionInstaller();
+  installer.install().catch(console.error);
+  } else {
+    console.log(
+      chalk.red("❌ Unknown command. Use: npx appiq-solution install")
+    );
+    process.exit(1);
+  }
+}
+
+module.exports = AppiqSolutionInstaller;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appiq-solution",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "🚀 Super einfache KI-Agent Installation mit One-Click Workflows - Built with ❤️ based on Bmad-Method",
   "main": "tools/appiq-installer.js",
   "bin": {