appiq-solution 1.0.0 → 1.0.2

package/appiq-installer.js

@@ -0,0 +1,1991 @@
+#!/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: BMAD Core Configuration Setup
+        await this.setupBMADCoreConfig();
+
+        // Phase 8: Document Templates & Dependencies
+        await this.setupDocumentTemplates();
+
+        // Phase 9: Agent Dependencies System
+        await this.setupAgentDependencies();
+
+        // Phase 10: BMAD Orchestration (Full Flow)
+        await this.setupBMADOrchestration();
+
+        // Phase 11: One-Click Setup
+        await this.setupOneClickWorkflows();
+
+        // Phase 12: 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 setupBMADCoreConfig() {
+      console.log(chalk.yellow("⚙️ BMAD Core Configuration einrichten..."));
+
+      // Create .bmad-core directory
+      const bmadCoreDir = path.join(this.appiqPath, '.bmad-core');
+      if (!fs.existsSync(bmadCoreDir)) {
+        fs.mkdirSync(bmadCoreDir, { recursive: true });
+      }
+
+      // Create core-config.yaml
+      const coreConfigPath = path.join(bmadCoreDir, 'core-config.yaml');
+      fs.writeFileSync(coreConfigPath, this.generateCoreConfig());
+
+      // Create technical-preferences.md
+      const techPrefsPath = path.join(bmadCoreDir, 'data');
+      if (!fs.existsSync(techPrefsPath)) {
+        fs.mkdirSync(techPrefsPath, { recursive: true });
+      }
+      fs.writeFileSync(path.join(techPrefsPath, 'technical-preferences.md'), this.generateTechnicalPreferences());
+
+      console.log(chalk.green("✅ BMAD Core Configuration bereit!\n"));
+    }
+
+    async setupDocumentTemplates() {
+      console.log(chalk.yellow("📄 Document Templates & Struktur einrichten..."));
+
+      // Create docs directory structure
+      const docsDir = path.join(this.projectRoot, 'docs');
+      const archDir = path.join(docsDir, 'architecture');
+      const storiesDir = path.join(docsDir, 'stories');
+
+      [docsDir, archDir, storiesDir].forEach(dir => {
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+      });
+
+      // Create templates
+      const templatesDir = path.join(this.appiqPath, 'templates');
+      if (!fs.existsSync(templatesDir)) {
+        fs.mkdirSync(templatesDir, { recursive: true });
+      }
+
+      // PRD Template
+      fs.writeFileSync(path.join(templatesDir, 'prd-template.md'), this.generatePRDTemplate());
+      
+      // Architecture Template
+      fs.writeFileSync(path.join(templatesDir, 'architecture-template.md'), this.generateArchitectureTemplate());
+      
+      // Story Template
+      fs.writeFileSync(path.join(templatesDir, 'story-template.md'), this.generateStoryTemplate());
+
+      // Create initial PRD if planning is complete
+      if (this.config.planApproved) {
+        fs.writeFileSync(path.join(docsDir, 'prd.md'), this.generateInitialPRD());
+      }
+
+      console.log(chalk.green("✅ Document Templates erstellt!\n"));
+    }
+
+    async setupAgentDependencies() {
+      console.log(chalk.yellow("🔗 Agent Dependencies System einrichten..."));
+
+      const agentsDir = path.join(this.appiqPath, "agents");
+      const tasksDir = path.join(this.appiqPath, 'tasks');
+      const dataDir = path.join(this.appiqPath, 'data');
+
+      // Create directories
+      [tasksDir, dataDir].forEach(dir => {
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+      });
+
+      // Create BMAD Knowledge Base
+      fs.writeFileSync(path.join(dataDir, 'bmad-kb.md'), this.generateBMADKnowledgeBase());
+
+      // Create essential tasks
+      fs.writeFileSync(path.join(tasksDir, 'create-doc.md'), this.generateCreateDocTask());
+      fs.writeFileSync(path.join(tasksDir, 'shard-doc.md'), this.generateShardDocTask());
+      fs.writeFileSync(path.join(tasksDir, 'validate-story.md'), this.generateValidateStoryTask());
+
+      // Update agents with proper dependencies
+      await this.updateAgentsWithDependencies();
+
+      console.log(chalk.green("✅ Agent Dependencies System bereit!\n"));
+    }
+
+    async setupBMADOrchestration() {
+      console.log(chalk.yellow("🎭 BMAD Full Orchestration einrichten..."));
+
+      // Create orchestration config based on BMAD Flow
+      const orchestrationConfig = {
+        planningPhase: {
+          agents: ["analyst", "pm", "ux-expert", "architect", "po"],
+          workflow: this.config.projectType === "greenfield" ? "greenfield-planning" : "brownfield-planning"
+        },
+        developmentPhase: {
+          agents: ["sm", "po", "dev", "qa"],
+          workflow: "core-development-cycle"
+        },
+        transitions: {
+          planningToIDE: "document-sharding",
+          criticalCommitPoints: ["before-next-story", "after-qa-approval"]
+        }
+      };
+
+      // Generate BMAD Orchestration
+      const orchestrationPath = path.join(this.appiqPath, "bmad-orchestration.yaml");
+      fs.writeFileSync(orchestrationPath, this.generateBMADOrchestration(orchestrationConfig));
+
+      // Create workflow guides
+      const workflowsDir = path.join(this.appiqPath, 'workflows');
+      if (!fs.existsSync(workflowsDir)) {
+        fs.mkdirSync(workflowsDir, { recursive: true });
+      }
+
+      fs.writeFileSync(path.join(workflowsDir, 'planning-workflow.md'), this.generatePlanningWorkflow());
+      fs.writeFileSync(path.join(workflowsDir, 'development-cycle.md'), this.generateDevelopmentCycle());
+      fs.writeFileSync(path.join(workflowsDir, 'document-sharding.md'), this.generateDocumentSharding());
+
+      console.log(chalk.green("✅ BMAD Full Orchestration bereit!\n"));
+    }
+
+  generateCoreConfig() {
+    return `# BMAD Core Configuration
+# Built with ❤️ based on Bmad-Method
+
+project:
+  name: ${this.config.projectName || 'Unbenanntes Projekt'}
+  type: ${this.config.projectType}
+  created: ${new Date().toISOString()}
+
+# Files that dev agent should ALWAYS load into context
+devLoadAlwaysFiles:
+  - docs/architecture/coding-standards.md
+  - docs/architecture/tech-stack.md
+  - docs/architecture/project-structure.md
+
+# Document paths configuration
+documentPaths:
+  prd: "docs/prd.md"
+  architecture: "docs/architecture.md"
+  stories: "docs/stories/"
+  templates: "appiq-solution/templates/"
+
+# Agent dependencies configuration
+dependencies:
+  templates:
+    - prd-template.md
+    - architecture-template.md
+    - story-template.md
+  tasks:
+    - create-doc.md
+    - shard-doc.md
+    - validate-story.md
+  data:
+    - bmad-kb.md
+    - technical-preferences.md
+`;
+  }
+
+  generateTechnicalPreferences() {
+    return `# Technical Preferences
+
+*Diese Datei hilft PM und Architect dabei, Ihre bevorzugten Design-Patterns und Technologien zu berücksichtigen.*
+
+## Projekt: ${this.config.projectName || 'Unbenanntes Projekt'}
+
+### Bevorzugte Technologien
+${this.config.projectType === 'greenfield' ? `
+**Frontend:**
+- Framework: React/Next.js, Vue/Nuxt, Angular
+- State Management: Zustand, Redux Toolkit, Pinia
+- Styling: Tailwind CSS, Material-UI, Ant Design
+
+**Backend:**
+- Runtime: Node.js, Python, Go
+- Framework: Express, FastAPI, Gin
+- Database: PostgreSQL, MongoDB, Redis
+
+**DevOps:**
+- Deployment: Vercel, Railway, AWS
+- CI/CD: GitHub Actions, GitLab CI
+- Monitoring: Sentry, LogRocket
+` : `
+**Bestehende Technologien erweitern:**
+- Kompatibilität mit bestehender Code-Basis beachten
+- Minimale neue Dependencies
+- Schrittweise Migration wenn nötig
+`}
+
+### Design Patterns
+- **Architektur:** Clean Architecture, Hexagonal, MVC
+- **Code Style:** DRY, SOLID Principles, KISS
+- **Testing:** TDD/BDD, Unit + Integration Tests
+- **Documentation:** README-driven, Inline Comments
+
+### Coding Standards
+- **Naming:** camelCase für Variablen, PascalCase für Components
+- **Files:** kebab-case für Dateien, PascalCase für Components  
+- **Functions:** Kleine, fokussierte Funktionen (<50 Zeilen)
+- **Comments:** Erkläre WARUM, nicht WAS
+
+### Präferenzen
+- **Performance:** Optimierung vor Abstraktion
+- **Security:** Security-by-Design
+- **Accessibility:** WCAG 2.1 AA Standard
+- **Mobile:** Mobile-First Approach
+
+---
+*Aktualisiert: ${new Date().toLocaleDateString('de-DE')}*
+`;
+  }
+
+  generatePRDTemplate() {
+    return `# Product Requirements Document (PRD)
+
+## Projekt: [PROJECT_NAME]
+
+### 1. Problem Statement
+*Welches Problem lösen wir?*
+
+### 2. Solution Overview  
+*Wie lösen wir das Problem?*
+
+### 3. Target Users
+*Wer sind unsere Zielgruppen?*
+
+### 4. Functional Requirements (FRs)
+*Was muss das System können?*
+
+#### 4.1 Core Features
+- [ ] Feature 1
+- [ ] Feature 2
+
+#### 4.2 Advanced Features  
+- [ ] Advanced Feature 1
+- [ ] Advanced Feature 2
+
+### 5. Non-Functional Requirements (NFRs)
+*Wie gut muss das System funktionieren?*
+
+#### 5.1 Performance
+- Response Time: < 200ms
+- Throughput: [SPECIFY]
+
+#### 5.2 Security
+- Authentication: [METHOD]
+- Authorization: [RBAC/ABAC]
+
+#### 5.3 Scalability
+- Users: [NUMBER]
+- Data: [VOLUME]
+
+### 6. User Stories & Epics
+
+#### Epic 1: [EPIC_NAME]
+- **Story 1.1:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+- **Story 1.2:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+
+#### Epic 2: [EPIC_NAME]  
+- **Story 2.1:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+- **Story 2.2:** Als [USER] möchte ich [ACTION] um [BENEFIT]
+
+### 7. Success Metrics
+*Wie messen wir Erfolg?*
+
+- Metric 1: [DEFINITION]
+- Metric 2: [DEFINITION]
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateArchitectureTemplate() {
+    return `# System Architecture
+
+## Projekt: [PROJECT_NAME]
+
+### 1. Architecture Overview
+*High-level Systemübersicht*
+
+### 2. Technology Stack
+
+#### Frontend
+- Framework: [FRAMEWORK]
+- State Management: [STATE_MANAGEMENT]
+- Styling: [STYLING_SOLUTION]
+
+#### Backend
+- Runtime: [RUNTIME]
+- Framework: [FRAMEWORK]
+- Database: [DATABASE]
+
+#### Infrastructure
+- Hosting: [HOSTING_PLATFORM]
+- CI/CD: [CI_CD_SOLUTION]
+
+### 3. System Components
+
+#### 3.1 Frontend Components
+- Component Library
+- State Management
+- Routing
+- API Layer
+
+#### 3.2 Backend Services
+- API Layer
+- Business Logic
+- Data Access Layer
+- External Integrations
+
+### 4. Data Models
+
+#### User Model
+\`\`\`
+{
+  id: string
+  email: string
+  name: string
+  createdAt: Date
+}
+\`\`\`
+
+### 5. API Design
+
+#### Authentication
+- POST /api/auth/login
+- POST /api/auth/register
+- POST /api/auth/logout
+
+#### Core Resources
+- GET /api/[resource]
+- POST /api/[resource]
+- PUT /api/[resource]/:id
+- DELETE /api/[resource]/:id
+
+### 6. Security Considerations
+- Authentication Strategy
+- Authorization Model
+- Data Validation
+- Rate Limiting
+
+### 7. Performance Considerations
+- Caching Strategy
+- Database Optimization
+- CDN Usage
+- Lazy Loading
+
+### 8. Deployment Architecture
+- Development Environment
+- Staging Environment
+- Production Environment
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateStoryTemplate() {
+    return `# User Story: [STORY_TITLE]
+
+## Story Details
+**Als** [USER_TYPE]  
+**möchte ich** [ACTION]  
+**um** [BENEFIT]
+
+## Acceptance Criteria
+- [ ] Criterion 1
+- [ ] Criterion 2
+- [ ] Criterion 3
+
+## Technical Tasks
+- [ ] Task 1: [DESCRIPTION]
+- [ ] Task 2: [DESCRIPTION]
+- [ ] Task 3: [DESCRIPTION]
+
+## Definition of Done
+- [ ] Code implemented and tested
+- [ ] Unit tests written and passing
+- [ ] Integration tests passing
+- [ ] Code reviewed and approved
+- [ ] Documentation updated
+- [ ] Deployed to staging
+- [ ] User acceptance testing completed
+
+## Dependencies
+- [ ] Dependency 1
+- [ ] Dependency 2
+
+## Estimation
+**Story Points:** [POINTS]  
+**Estimated Hours:** [HOURS]
+
+## Notes
+*Zusätzliche Notizen und Überlegungen*
+
+---
+**Sprint:** [SPRINT_NUMBER]  
+**Assigned to:** [DEVELOPER]  
+**Status:** [TODO/IN_PROGRESS/REVIEW/DONE]
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateInitialPRD() {
+    const { projectName, projectIdea, targetUsers, projectType } = this.config;
+    
+    return `# Product Requirements Document (PRD)
+
+## Projekt: ${projectName}
+
+### 1. Problem Statement
+${projectIdea}
+
+### 2. Target Users
+${targetUsers}
+
+### 3. Project Type
+${projectType === 'greenfield' ? '✨ Greenfield (Neues Projekt)' : '🔧 Brownfield (Bestehendes Projekt)'}
+
+### 4. Functional Requirements (FRs)
+*Diese Sektion wird durch den PM Agent vervollständigt*
+
+#### 4.1 Core Features
+- [ ] Feature wird durch PM definiert
+
+### 5. Non-Functional Requirements (NFRs)
+*Diese Sektion wird durch den Architect Agent vervollständigt*
+
+### 6. User Stories & Epics
+*Diese Sektion wird durch den Story Master Agent vervollständigt*
+
+---
+**Status:** 📋 Planning Phase Complete - Ready for PM Agent  
+**Nächster Schritt:** PM Agent für detaillierte Requirements  
+**Created:** ${new Date().toLocaleDateString('de-DE')}
+
+---
+*Erstellt mit Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateBMADKnowledgeBase() {
+    return `# BMAD Knowledge Base
+
+## The BMad Planning + Execution Workflow
+
+### Planning Workflow (Web UI or Powerful IDE Agents)
+1. **Analyst** (Optional): Market Research, Competitor Analysis, Project Brief
+2. **PM**: Create PRD from Brief with FRs, NFRs, Epics & Stories
+3. **UX Expert** (Optional): Create Front End Spec, Generate UI Prompts
+4. **Architect**: Create Architecture from PRD + UX Spec
+5. **PO**: Run Master Checklist, validate document alignment
+
+### Critical Transition: Web UI → IDE
+- Copy documents to project (docs/prd.md, docs/architecture.md)
+- Switch to IDE
+- **PO**: Shard Documents (CRITICAL STEP)
+- Begin Development Cycle
+
+### Core Development Cycle (IDE)
+1. **SM**: Review previous story dev/QA notes
+2. **SM**: Draft next story from sharded epic + architecture
+3. **PO**: Validate story draft (optional)
+4. **User Approval** of story
+5. **Dev**: Sequential task execution, implement tasks + tests
+6. **Dev**: Run all validations, mark ready for review
+7. **User Verification**: Request QA or approve
+8. **QA**: Senior dev review + active refactoring (if requested)
+9. **IMPORTANT**: Verify all regression tests and linting pass
+10. **IMPORTANT**: COMMIT CHANGES BEFORE PROCEEDING
+11. Mark story as done, loop back to SM
+
+### Key Principles
+- **Document Sharding**: Critical step after planning phase
+- **Context Management**: Keep files lean and focused
+- **Commit Regularly**: Save work frequently, especially after QA
+- **Agent Selection**: Use appropriate agent for each task
+- **Dependencies**: Each agent loads only what it needs
+
+### Special Agents
+- **BMad-Master**: Can do any task except story implementation
+- **BMad-Orchestrator**: Heavy-weight agent for web bundles only
+
+### Technical Configuration
+- **core-config.yaml**: devLoadAlwaysFiles configuration
+- **technical-preferences.md**: Bias PM/Architect recommendations
+- **Dependencies**: templates, tasks, data for each agent
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateCreateDocTask() {
+    return `# Create Document Task
+
+## Purpose
+Create structured documents following BMAD templates and standards.
+
+## Usage
+This task helps agents create consistent, well-structured documents.
+
+## Process
+1. **Identify Document Type**: PRD, Architecture, Story, etc.
+2. **Load Template**: Use appropriate template from templates/
+3. **Gather Requirements**: Collect all necessary information
+4. **Fill Template**: Replace placeholders with actual content
+5. **Validate Structure**: Ensure all sections are complete
+6. **Save Document**: Store in correct location (docs/)
+
+## Templates Available
+- prd-template.md
+- architecture-template.md
+- story-template.md
+
+## Best Practices
+- Follow template structure exactly
+- Replace ALL placeholders
+- Include creation date and status
+- Link to related documents
+- Use consistent formatting
+
+## Output Location
+- PRD: docs/prd.md
+- Architecture: docs/architecture.md
+- Stories: docs/stories/[story-name].md
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateShardDocTask() {
+    return `# Document Sharding Task
+
+## Purpose
+**CRITICAL STEP**: Break down large documents into focused, manageable pieces for agents.
+
+## When to Use
+- After planning phase completion
+- Before beginning development cycle
+- When switching from Web UI to IDE
+
+## Process
+1. **Identify Source Document**: Usually PRD or Architecture
+2. **Analyze Structure**: Find natural breaking points
+3. **Create Focused Files**: Each file serves one purpose
+4. **Maintain References**: Link shards together
+5. **Update devLoadAlwaysFiles**: Configure core-config.yaml
+
+## Sharding Strategy
+
+### PRD Sharding
+- **Core Requirements**: docs/requirements/core.md
+- **User Stories**: docs/stories/ (individual files)
+- **Success Metrics**: docs/metrics.md
+
+### Architecture Sharding
+- **Tech Stack**: docs/architecture/tech-stack.md
+- **Coding Standards**: docs/architecture/coding-standards.md
+- **Project Structure**: docs/architecture/project-structure.md
+- **API Design**: docs/architecture/api-design.md
+- **Data Models**: docs/architecture/data-models.md
+
+## Critical Points
+- **Lean Files**: Each shard should be focused and minimal
+- **Dev Context**: Sharded files go into devLoadAlwaysFiles
+- **Agent Performance**: Smaller context = better performance
+- **Maintainability**: Easier to update specific aspects
+
+## Post-Sharding
+1. Update core-config.yaml devLoadAlwaysFiles
+2. Verify all shards are accessible
+3. Test agent context loading
+4. Begin development cycle
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateValidateStoryTask() {
+    return `# Validate Story Task
+
+## Purpose
+Ensure user stories align with PRD, architecture, and project goals.
+
+## When to Use
+- Before story implementation begins
+- When SM drafts new stories
+- When stories are modified
+
+## Validation Checklist
+
+### Story Structure
+- [ ] Clear user role defined
+- [ ] Specific action described
+- [ ] Business value stated
+- [ ] Acceptance criteria present
+
+### Technical Alignment
+- [ ] Aligns with architecture decisions
+- [ ] Fits within tech stack constraints
+- [ ] Dependencies identified
+- [ ] Implementation feasible
+
+### Business Alignment
+- [ ] Supports PRD objectives
+- [ ] Addresses user needs
+- [ ] Measurable outcomes
+- [ ] Priority justified
+
+### Quality Gates
+- [ ] Testable acceptance criteria
+- [ ] Definition of done complete
+- [ ] Effort estimation reasonable
+- [ ] Risk assessment done
+
+## Process
+1. **Load References**: PRD, Architecture, related stories
+2. **Check Structure**: Verify story template compliance
+3. **Validate Alignment**: Against PRD and architecture
+4. **Assess Dependencies**: Identify blockers or prerequisites
+5. **Review Quality**: Ensure story is ready for development
+6. **Provide Feedback**: Clear recommendations for improvements
+
+## Common Issues
+- Vague acceptance criteria
+- Missing technical dependencies
+- Misalignment with architecture
+- Unrealistic scope or effort
+
+## Output
+- **Validation Status**: Pass/Fail with reasons
+- **Recommendations**: Specific improvements needed
+- **Dependencies**: List of prerequisites
+- **Risk Assessment**: Potential implementation challenges
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  async updateAgentsWithDependencies() {
+    console.log(chalk.gray("    🔗 Updating agents with BMAD dependencies..."));
+
+    const agentsDir = path.join(this.appiqPath, "agents");
+    const agents = fs.readdirSync(agentsDir);
+
+    for (const agentFile of agents) {
+      const agentPath = path.join(agentsDir, agentFile);
+      let content = fs.readFileSync(agentPath, 'utf8');
+
+      // Add BMAD dependencies section to each agent
+      const dependenciesSection = `
+
+## 🔗 BMAD Dependencies
+
+### Templates
+- prd-template.md
+- architecture-template.md  
+- story-template.md
+
+### Tasks
+- create-doc.md
+- shard-doc.md
+- validate-story.md
+
+### Data
+- bmad-kb.md
+- technical-preferences.md
+
+### Configuration
+- core-config.yaml (devLoadAlwaysFiles)
+
+## 🎯 BMAD Workflow Integration
+
+**Planning Phase:** Web UI → IDE Transition → Document Sharding  
+**Development Phase:** SM → PO → Dev → QA → Loop  
+**Critical Points:** Commit before proceeding, verify tests passing
+
+`;
+
+      // Add dependencies section before the final line
+      const lines = content.split('\n');
+      const lastLine = lines.pop(); // Remove last line
+      lines.push(dependenciesSection);
+      lines.push(lastLine); // Add last line back
+
+      fs.writeFileSync(agentPath, lines.join('\n'));
+    }
+  }
+
+  generateBMADOrchestration(config) {
+    return `# BMAD Full Orchestration
+# Built with ❤️ based on Bmad-Method
+
+project:
+  name: ${this.config.projectName}
+  type: ${this.config.projectType}
+  plan_approved: ${this.config.planApproved}
+  created: ${new Date().toISOString()}
+
+# BMAD Planning Phase (Web UI/Powerful IDE)
+planning_phase:
+  workflow: ${config.planningPhase.workflow}
+  agents:
+${config.planningPhase.agents.map(agent => `    - ${agent}`).join('\n')}
+  
+  flow:
+    1: "analyst → research & project brief (optional)"
+    2: "pm → create PRD from brief"
+    3: "ux-expert → create frontend spec (optional)"
+    4: "architect → create architecture from PRD + UX"
+    5: "po → run master checklist & validate alignment"
+
+# Critical Transition: Web UI → IDE
+transition:
+  type: ${config.transitions.planningToIDE}
+  requirements:
+    - "Copy docs/prd.md and docs/architecture.md to project"
+    - "Switch to IDE"
+    - "PO: Shard documents (CRITICAL)"
+    - "Update core-config.yaml devLoadAlwaysFiles"
+
+# BMAD Development Phase (IDE Only)
+development_phase:
+  workflow: ${config.developmentPhase.workflow}
+  agents:
+${config.developmentPhase.agents.map(agent => `    - ${agent}`).join('\n')}
+  
+  cycle:
+    1: "sm → review previous story dev/QA notes"
+    2: "sm → draft next story from sharded epic + architecture"
+    3: "po → validate story draft (optional)"
+    4: "user → approve story"
+    5: "dev → sequential task execution + implementation"
+    6: "dev → run all validations, mark ready for review"
+    7: "user → verify (request QA or approve)"
+    8: "qa → senior dev review + active refactoring (if requested)"
+    9: "CRITICAL → verify regression tests + linting pass"
+    10: "CRITICAL → COMMIT CHANGES BEFORE PROCEEDING"
+    11: "mark story done → loop back to sm"
+
+# Critical Commit Points
+commit_points:
+${config.transitions.criticalCommitPoints.map(point => `  - ${point}`).join('\n')}
+
+# IDE Integration
+ides:
+${this.config.selectedIDEs.map(ide => `  - name: ${this.getIDEName(ide)}
+    config_path: ${this.getIDEConfig(ide).dir}
+    file_format: ${this.getIDEConfig(ide).suffix}`).join('\n')}
+
+# Context Management
+context:
+  dev_always_files:
+    - docs/architecture/coding-standards.md
+    - docs/architecture/tech-stack.md
+    - docs/architecture/project-structure.md
+  
+  agent_dependencies:
+    templates: ["prd-template.md", "architecture-template.md", "story-template.md"]
+    tasks: ["create-doc.md", "shard-doc.md", "validate-story.md"]
+    data: ["bmad-kb.md", "technical-preferences.md"]
+
+---
+*Powered by Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generatePlanningWorkflow() {
+    return `# BMAD Planning Workflow
+
+## Übersicht
+Die Planungsphase folgt einem strukturierten Workflow, idealerweise in Web UI für Kosteneffizienz.
+
+## Planning Flow
+
+### 1. Start: Projektidee
+- Grundlegendes Konzept definiert
+- Problem identifiziert
+
+### 2. Analyst (Optional)
+**Brainstorming:**
+- Marktforschung
+- Konkurrenzanalyse  
+- Projekt Brief erstellen
+
+### 3. Project Manager (PM)
+**PRD Erstellung:**
+- PRD aus Brief erstellen (Fast Track)
+- ODER interaktive PRD Erstellung (mehr Fragen)
+- Functional Requirements (FRs)
+- Non-Functional Requirements (NFRs)
+- Epics & Stories definieren
+
+### 4. UX Expert (Optional)
+**Frontend Specification:**
+- Frontend Spec erstellen
+- UI Prompts für Lovable/V0 generieren (optional)
+
+### 5. System Architect  
+**Architektur Design:**
+- Architektur aus PRD erstellen
+- ODER aus PRD + UX Spec erstellen
+- Tech Stack definieren
+- System Components planen
+
+### 6. Product Owner (PO)
+**Master Checklist:**
+- Dokumenten-Alignment prüfen
+- Epics & Stories aktualisieren (falls nötig)
+- PRD/Architektur anpassen (falls nötig)
+
+## Kritischer Übergang: Web UI → IDE
+
+### ⚠️ WICHTIG: Transition Point
+Sobald PO Dokumenten-Alignment bestätigt:
+
+1. **Dokumente kopieren**: docs/prd.md und docs/architecture.md
+2. **IDE wechseln**: Projekt in bevorzugter Agentic IDE öffnen  
+3. **Document Sharding**: PO Agent zum Shard der Dokumente verwenden
+4. **Development beginnen**: Core Development Cycle starten
+
+## Qualitäts-Gates
+
+### Planning Complete Criteria
+- [ ] PRD vollständig und genehmigt
+- [ ] Architektur vollständig und genehmigt
+- [ ] UX Spec (falls erforderlich) genehmigt
+- [ ] Alle Dokumente sind aligned
+- [ ] Epics und Stories definiert
+- [ ] Übergang zu IDE vorbereitet
+
+## Nächste Schritte
+Nach Planning Complete → **Document Sharding** → **Development Cycle**
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateDevelopmentCycle() {
+    return `# BMAD Core Development Cycle
+
+## Übersicht
+Strukturierter Entwicklungsworkflow in der IDE nach abgeschlossener Planungsphase.
+
+## Voraussetzungen
+- ✅ Planning Phase abgeschlossen
+- ✅ Dokumente in Projekt kopiert (docs/prd.md, docs/architecture.md)
+- ✅ **Document Sharding** durch PO Agent durchgeführt
+- ✅ IDE-Setup komplett
+
+## Development Cycle Flow
+
+### 1. Scrum Master (SM)
+**Story Vorbereitung:**
+- Review previous story dev/QA notes
+- Draft next story from sharded epic + architecture
+- Berücksichtigt technical dependencies
+- Erstellt realistische task breakdown
+
+### 2. Product Owner (PO) - Optional
+**Story Validation:**
+- Validate story draft against artifacts
+- Überprüft alignment mit PRD
+- Bestätigt business value
+- Kann übersprungen werden bei erfahrenen Teams
+
+### 3. User Approval
+**Story Freigabe:**
+- ✅ **Approved**: Weiter zu Development
+- ❌ **Needs Changes**: Zurück zu SM für Anpassungen
+
+### 4. Developer (Dev)
+**Implementation:**
+- Sequential task execution
+- Implement tasks + tests
+- Run all validations
+- Mark ready for review + add notes
+- Dokumentiert implementation decisions
+
+### 5. User Verification
+**Review Decision:**
+- 🔍 **Request QA Review**: Weiter zu QA Agent
+- ✅ **Approve Without QA**: Direkt zu Final Checks
+- ❌ **Needs Fixes**: Zurück zu Dev
+
+### 6. QA Agent (Optional)
+**Quality Assurance:**
+- Senior dev review + active refactoring
+- Review code, refactor, add tests
+- Document notes and improvements
+- **Decision**: Needs Dev Work OR Approved
+
+### 7. Final Checks - ⚠️ CRITICAL
+**Vor dem Abschluss:**
+- ✅ Verify ALL regression tests passing
+- ✅ Verify ALL linting passing  
+- ✅ Code review completed (if QA was used)
+- ✅ Documentation updated
+
+### 8. Commit - ⚠️ SUPER CRITICAL
+**WICHTIG: COMMIT YOUR CHANGES BEFORE PROCEEDING!**
+- Git add & commit all changes
+- Include meaningful commit message
+- Push to repository
+
+### 9. Story Complete
+**Mark als Done:**
+- Story status → DONE
+- Loop back to SM for next story
+
+## Critical Points
+
+### ⚠️ Commit Points
+- **After QA Approval**: Always commit before marking done
+- **Before Next Story**: Clean state for next iteration
+
+### 🎯 Quality Gates
+- All tests passing
+- Linting clean
+- Code reviewed (if QA used)
+- Documentation current
+
+### 📊 Context Management
+- Keep relevant files only in context
+- Use sharded documents
+- Maintain lean, focused files
+
+## Best Practices
+- **Small Stories**: Keep stories manageable (< 1 week)
+- **Regular Commits**: Commit frequently during development
+- **Test First**: Write tests before or with implementation
+- **Document Decisions**: Record architectural decisions
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  generateDocumentSharding() {
+    return `# Document Sharding Guide
+
+## ⚠️ CRITICAL STEP
+Document Sharding ist ein **essentieller Schritt** im BMAD Flow nach der Planungsphase.
+
+## Wann Document Sharding durchführen?
+- ✅ Nach Planning Phase Completion
+- ✅ Beim Übergang von Web UI zu IDE  
+- ✅ Vor Beginn des Development Cycles
+- ✅ Wenn Dokumente zu groß für Agent-Context werden
+
+## Warum Document Sharding?
+- **Performance**: Kleinere Context = bessere Agent-Performance
+- **Focus**: Jede Datei dient einem spezifischen Zweck
+- **Maintainability**: Einfacher zu aktualisieren und zu verwalten
+- **Agent Efficiency**: Agents laden nur was sie brauchen
+
+## Sharding Process
+
+### 1. PRD Sharding
+**Source**: docs/prd.md  
+**Target Structure**:
+\`\`\`
+docs/
+├── requirements/
+│   ├── core.md              # Core functional requirements
+│   ├── non-functional.md    # NFRs (performance, security)
+│   └── success-metrics.md   # KPIs and success criteria
+├── stories/
+│   ├── epic-1-auth/
+│   │   ├── story-1-1-login.md
+│   │   └── story-1-2-register.md
+│   └── epic-2-dashboard/
+│       └── story-2-1-overview.md
+\`\`\`
+
+### 2. Architecture Sharding  
+**Source**: docs/architecture.md  
+**Target Structure**:
+\`\`\`
+docs/architecture/
+├── tech-stack.md           # Technology decisions
+├── coding-standards.md     # Code style and patterns  
+├── project-structure.md    # File/folder organization
+├── api-design.md          # REST/GraphQL API specs
+├── data-models.md         # Database schema
+├── security.md            # Security considerations
+└── deployment.md          # Deployment architecture
+\`\`\`
+
+## Sharding Guidelines
+
+### File Size
+- **Target**: < 50 lines per sharded file
+- **Maximum**: < 100 lines per sharded file
+- **Focus**: One concern per file
+
+### Naming Convention
+- **kebab-case**: tech-stack.md, coding-standards.md
+- **Descriptive**: Clear purpose from filename
+- **Consistent**: Follow project conventions
+
+### Content Rules
+- **Atomic**: Each file covers one topic completely
+- **Self-contained**: Can be understood independently
+- **Linked**: Reference related files when needed
+- **Lean**: Remove fluff, keep essentials
+
+## Post-Sharding Configuration
+
+### 1. Update core-config.yaml
+\`\`\`yaml
+devLoadAlwaysFiles:
+  - docs/architecture/coding-standards.md
+  - docs/architecture/tech-stack.md  
+  - docs/architecture/project-structure.md
+\`\`\`
+
+### 2. Verify Agent Access
+- Test that agents can load sharded files
+- Ensure all references are correct
+- Validate file paths in configuration
+
+### 3. Update Templates
+- Modify templates to reference sharded structure
+- Update agent prompts to use sharded files
+- Test template generation
+
+## Quality Checks
+
+### ✅ Sharding Complete Criteria
+- [ ] All large documents sharded
+- [ ] Each shard < 100 lines
+- [ ] devLoadAlwaysFiles updated
+- [ ] Agent dependencies resolved
+- [ ] File references working
+- [ ] Templates updated
+
+### 🚨 Common Mistakes
+- **Too Large**: Shards still too big (>100 lines)
+- **Too Small**: Over-sharding (many 5-line files)
+- **Broken Links**: References to old unified files
+- **Missing Config**: devLoadAlwaysFiles not updated
+
+## After Sharding
+1. **Test Agent Loading**: Verify agents can access all needed files
+2. **Begin Development**: Start Core Development Cycle
+3. **Monitor Performance**: Watch for context issues
+4. **Refine as Needed**: Adjust sharding based on usage
+
+---
+*Built with ❤️ based on Bmad-Method*
+`;
+  }
+
+  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 - BMAD Workflow Guide
+
+## Projekt: ${this.config.projectName || "Unbenanntes Projekt"}
+**Typ:** ${
+      this.config.projectType === "greenfield" ? "✨ Greenfield (Neues Projekt)" : "🔧 Brownfield (Bestehendes Projekt)"
+    }
+
+## 📋 BMAD Planning Workflow (Phase 1)
+
+### Option A: Web UI Planning (Kosteneffizient)
+1. Claude/Gemini/GPT mit team-fullstack Bundle verwenden
+2. **Flow:** Analyst → PM → UX Expert → Architect → PO
+3. **Output:** docs/prd.md, docs/architecture.md
+
+### Option B: IDE Planning (Leistungsstark)
+\`\`\`
+@analyst → Market Research & Project Brief
+@pm → PRD mit FRs, NFRs, Epics & Stories erstellen
+@ux-expert → Frontend Spec (optional)
+@architect → System Architecture design  
+@po → Master Checklist & Document Alignment
+\`\`\`
+
+## ⚠️ KRITISCHER ÜBERGANG: Document Sharding
+
+**ESSENTIAL STEP:**
+\`\`\`
+@po bitte shard die PRD und Architecture Dokumente in fokussierte Dateien
+\`\`\`
+
+**Das erstellt:**
+- docs/architecture/tech-stack.md ← Dev lädt immer
+- docs/architecture/coding-standards.md ← Dev lädt immer  
+- docs/architecture/project-structure.md ← Dev lädt immer
+- docs/requirements/core.md
+- docs/stories/ (individual story files)
+
+## 🚀 BMAD Development Cycle (Phase 2)
+
+### Core Development Loop:
+\`\`\`
+1. @sm → Review previous notes, draft next story from sharded epic
+2. @po → Validate story draft (optional)
+3. User → Approve story
+4. @dev → Sequential tasks, implement + tests, mark ready  
+5. User → Verify (request QA or approve)
+6. @qa → Senior dev review + refactoring (optional)
+7. ⚠️ CRITICAL: Verify tests + linting pass
+8. ⚠️ SUPER CRITICAL: COMMIT CHANGES BEFORE PROCEEDING!
+9. Mark story done → Loop back to @sm
+\`\`\`
+
+## 🎯 One-Click Commands
+
+### Planning:
+- \`/plan\` → Start planning workflow
+- \`/prd\` → Generate PRD
+- \`/arch\` → Design architecture
+
+### Critical Transition:
+- \`/shard\` → Document sharding (ESSENTIAL!)
+
+### Development:
+- \`/story\` → Draft next story
+- \`/dev\` → Start development
+- \`/test\` → Run tests
+- \`/qa\` → Request review
+- \`/commit\` → Commit changes
+
+### ${this.config.projectType === "greenfield" ? "Greenfield" : "Brownfield"} Specific:
+${this.config.projectType === "greenfield" ? `
+- \`/start\` → Fresh project setup
+- \`/design\` → Create from scratch
+- \`/build\` → Build step by step
+` : `
+- \`/analyze\` → Analyze existing code
+- \`/document\` → Document current state
+- \`/improve\` → Plan improvements
+`}
+
+## 📊 File Structure
+
+\`\`\`
+your-project/
+├── docs/
+│   ├── prd.md              ← Initial PRD
+│   ├── architecture.md     ← Initial Architecture
+│   ├── architecture/       ← Sharded files
+│   │   ├── tech-stack.md
+│   │   ├── coding-standards.md
+│   │   └── project-structure.md
+│   ├── requirements/
+│   │   └── core.md
+│   └── stories/
+│       ├── epic-1-auth/
+│       └── epic-2-features/
+├── appiq-solution/
+│   ├── agents/             ← AI-Agents
+│   ├── templates/          ← Document templates
+│   ├── workflows/          ← Workflow guides
+│   └── .bmad-core/         ← BMAD configuration
+└── .cursor/rules/          ← IDE integration
+\`\`\`
+
+## ⚠️ Critical Success Factors
+
+### Document Sharding (ESSENTIAL):
+- **MUST DO** after planning phase
+- Creates focused, lean files for agents
+- Improves agent performance dramatically
+
+### Commit Points:
+- After QA approval (always!)
+- Before next story (clean state)
+- Regular commits during development
+
+### Quality Gates:
+- All tests passing ✅
+- Linting clean ✅  
+- Code reviewed (if QA used) ✅
+- Documentation updated ✅
+
+## 🆘 Help & Support
+
+- \`/help\` → Show all commands
+- \`/workflow\` → Current workflow step
+- \`/agents\` → Available agents
+- \`/docs\` → Documentation
+
+### Workflow Files:
+- appiq-solution/workflows/planning-workflow.md
+- appiq-solution/workflows/development-cycle.md
+- appiq-solution/workflows/document-sharding.md
+
+---
+**IDEs:** ${this.config.selectedIDEs.map((ide) => this.getIDEName(ide)).join(", ")}  
+**Created:** ${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. 📋 BMAD Planning Workflow:"));
+    if (this.config.planApproved) {
+      console.log(chalk.green(`   ✅ Planning Complete - Ready for Development!`));
+      console.log(chalk.cyan(`   → Ihre initial PRD: docs/prd.md`));
+    } else {
+      console.log(chalk.cyan(`   Option A: Web UI (kosteneffizient)`));
+      console.log(chalk.gray(`   → Claude/Gemini/GPT mit Agents verwenden`));
+      console.log(chalk.cyan(`   Option B: Direkt in IDE`));
+      console.log(chalk.gray(`   → @pm für PRD, @architect für Architecture`));
+    }
+    console.log('');
+
+    console.log(chalk.yellow("3. ⚠️ KRITISCHER ÜBERGANG: Document Sharding"));
+    console.log(chalk.red(`   → Sagen Sie Ihrer IDE: ${chalk.bold('"@po bitte shard die PRD und Architecture Dokumente"')}`));
+    console.log(chalk.gray(`   → Dokumente werden in fokussierte Teile aufgeteilt\n`));
+
+    console.log(chalk.yellow("4. 🚀 BMAD Development Cycle:"));
+    console.log(chalk.cyan(`   1. @sm → Story Draft von Sharded Epic`));
+    console.log(chalk.cyan(`   2. @po → Story Validation (optional)`));
+    console.log(chalk.cyan(`   3. User → Story Approval`));
+    console.log(chalk.cyan(`   4. @dev → Implementation + Tests`));
+    console.log(chalk.cyan(`   5. @qa → Code Review (optional)`));
+    console.log(chalk.red(`   6. ⚠️ COMMIT CHANGES BEFORE PROCEEDING!`));
+    console.log(chalk.gray(`   → Loop zurück zu @sm für nächste Story\n`));
+
+    console.log(chalk.yellow("5. 🎯 Quick Commands (in quick-start.md):"));
+    console.log(chalk.cyan(`   /plan → Planning starten`));
+    console.log(chalk.cyan(`   /shard → Document Sharding`)); 
+    console.log(chalk.cyan(`   /story → Nächste Story`));
+    console.log(chalk.cyan(`   /dev → Development`));
+    console.log(chalk.cyan(`   /qa → Quality Review`));
+    console.log(chalk.gray(`   → Alle Details in appiq-solution/workflows/\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;