appiq-solution 1.0.1 → 1.0.2

package/appiq-installer.js

@@ -41,30 +41,39 @@ class AppiqSolutionInstaller {
     try {
       // Phase 1: Projekt-Typ Detection
       await this.detectProjectType();
-      
-        // Phase 2: Projektidee erfassen
-        await this.collectProjectIdea();
 
-        // Phase 3: IDE Selection (MULTISELECT)
+      // 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 4: Projektplan erstellen
+      await this.createProjectPlan();
 
-                // Phase 6: Installation
+      // 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();
+              // 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);
@@ -73,7 +82,7 @@ class AppiqSolutionInstaller {
 
   async detectProjectType() {
     console.log(chalk.yellow("🔍 Projekt-Analyse..."));
-    
+
     // Auto-Detection
     const hasPackageJson = fs.existsSync(
       path.join(this.projectRoot, "package.json")
@@ -83,15 +92,15 @@ class AppiqSolutionInstaller {
     );
     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(
@@ -102,7 +111,7 @@ class AppiqSolutionInstaller {
         }`
       )
     );
-    
+
     // User Confirmation
     const { projectType } = await inquirer.prompt([
       {
@@ -128,7 +137,7 @@ class AppiqSolutionInstaller {
         default: suggestedType,
       },
     ]);
-    
+
     this.config.projectType = projectType;
     console.log(
       chalk.green(
@@ -143,14 +152,19 @@ class AppiqSolutionInstaller {
 
   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.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)",
+        message:
+          "🎯 Welche IDEs nutzen Sie? (SPACEBAR = auswählen, ENTER = bestätigen)",
         choices: [
           { name: "🔵 Cursor", value: "cursor" },
           { name: "🟣 Claude Code CLI", value: "claude-code" },
@@ -171,7 +185,7 @@ class AppiqSolutionInstaller {
     ]);
 
     this.config.selectedIDEs = ides;
-    const ideNames = ides.map(ide => this.getIDEName(ide)).join(", ");
+    const ideNames = ides.map((ide) => this.getIDEName(ide)).join(", ");
     console.log(chalk.green(`✅ IDEs: ${ideNames}\n`));
   }
 
@@ -184,20 +198,25 @@ class AppiqSolutionInstaller {
         type: "input",
         name: "projectName",
         message: "🏷️ Wie soll Ihr Projekt heißen?",
-        validate: (input) => input.length > 0 ? true : "Bitte geben Sie einen Projektnamen ein!"
+        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!"
+        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!"
-      }
+        validate: (input) =>
+          input.length > 0 ? true : "Bitte beschreiben Sie Ihre Zielgruppe!",
+      },
     ]);
 
     this.config.projectName = projectName;
@@ -227,14 +246,15 @@ class AppiqSolutionInstaller {
         type: "confirm",
         name: "approved",
         message: "✅ Sind Sie mit diesem Plan zufrieden?",
-        default: true
+        default: true,
       },
       {
         type: "input",
         name: "changes",
-        message: "📝 Welche Änderungen möchten Sie? (oder ENTER für keine Änderungen)",
-        when: (answers) => !answers.approved
-      }
+        message:
+          "📝 Welche Änderungen möchten Sie? (oder ENTER für keine Änderungen)",
+        when: (answers) => !answers.approved,
+      },
     ]);
 
     if (!approved && changes) {
@@ -243,7 +263,9 @@ class AppiqSolutionInstaller {
       // 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"));
+      console.log(
+        chalk.green("✅ Plan freigegeben - Entwicklung kann starten!\n")
+      );
     }
 
     this.config.planApproved = true;
@@ -251,17 +273,23 @@ class AppiqSolutionInstaller {
 
   generateProjectPlan() {
     const { projectType, projectName, projectIdea, targetUsers } = this.config;
-    
+
     return `🎯 PROJEKTPLAN: ${projectName}
 
-📊 PROJEKT-TYP: ${projectType === 'greenfield' ? 'Greenfield (Neues Projekt)' : 'Brownfield (Bestehendes Projekt)'}
+📊 PROJEKT-TYP: ${
+      projectType === "greenfield"
+        ? "Greenfield (Neues Projekt)"
+        : "Brownfield (Bestehendes Projekt)"
+    }
 👥 ZIELGRUPPE: ${targetUsers}
 
 💡 PROJEKTIDEE:
 ${projectIdea}
 
 🚀 ENTWICKLUNGS-PIPELINE:
-${projectType === 'greenfield' ? `
+${
+  projectType === "greenfield"
+    ? `
 1. 📋 PO (Product Owner) → PRD erstellen
 2. 🏗️ Architect → System-Architektur designen  
 3. 🎨 UX Expert → UI/UX Design
@@ -269,14 +297,16 @@ ${projectType === 'greenfield' ? `
 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
@@ -286,82 +316,1099 @@ ${projectType === 'greenfield' ? `
 - /deploy → Deployment vorbereiten`;
   }
 
-  async setupAgentOrchestration() {
-    console.log(chalk.yellow("🎭 Agent-Orchestrierung 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;
     
-    // 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
-    };
+    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)'}
 
-    // Orchestrierung-Datei erstellen
-    const orchestrationPath = path.join(this.appiqPath, 'orchestration.yaml');
-    fs.writeFileSync(orchestrationPath, this.generateOrchestrationConfig(orchestrationConfig));
+### 4. Functional Requirements (FRs)
+*Diese Sektion wird durch den PM Agent vervollständigt*
 
-    console.log(chalk.green("✅ Agent-Orchestrierung vorbereitet!\n"));
+#### 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*
+`;
   }
 
-  generateOrchestrationConfig(config) {
-    return `# Appiq Solution Agent Orchestration
+  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()}
 
-agents:
-${config.agents.map(agent => `  - ${agent}`).join('\n')}
+# 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')}
 
-workflows:
-${config.workflows.map(workflow => `  - ${workflow}`).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"]
 
-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"
+---
+*Powered by Appiq Solution - Built with ❤️ based on Bmad-Method*
+`;
+  }
 
-ides:
-${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
+  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",
@@ -371,7 +1418,7 @@ ${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
       "developer",
       "qa-expert",
     ];
-    
+
     for (const agent of agents) {
       await this.createOptimizedAgent(agent);
     }
@@ -425,7 +1472,7 @@ ${this.config.selectedIDEs.map(ide => `  - ${ide}`).join('\n')}
     };
 
     const config = agentConfigs[agentName];
-    
+
     return `# ${config.name}
 
 ## 🎯 Rolle
@@ -455,7 +1502,9 @@ ${
 3. **Verwenden Sie:** ${config.commands[0]} für Quick-Start
 
 ---
-*Automatisch optimiert für ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}*
+*Automatisch optimiert für ${this.config.selectedIDEs
+      .map((ide) => this.getIDEName(ide))
+      .join(", ")}*
 *Powered by Appiq - Based on Bmad-Method*
 `;
   }
@@ -546,116 +1595,204 @@ ${
 
   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
+    return `# 🚀 Appiq Solution - BMAD Workflow Guide
 
-## Für ${
-      this.config.projectType === "greenfield" ? "NEUE" : "BESTEHENDE"
-    } Projekte
+## Projekt: ${this.config.projectName || "Unbenanntes Projekt"}
+**Typ:** ${
+      this.config.projectType === "greenfield" ? "✨ Greenfield (Neues Projekt)" : "🔧 Brownfield (Bestehendes Projekt)"
+    }
 
-### ⚡ One-Command Start:
+## 📋 BMAD Planning Workflow (Phase 1)
 
-\`\`\`bash
-# In Ihrer IDE, kopieren Sie einfach:
-${
-  this.config.projectType === "greenfield"
-    ? "/start new-project"
-    : "/analyze existing-project"
-}
+### 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
 \`\`\`
 
-### 📁 Wo gehört was hin?
+## ⚠️ KRITISCHER ÜBERGANG: Document Sharding
 
-${
-  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
+**ESSENTIAL STEP:**
+\`\`\`
+@po bitte shard die PRD und Architecture Dokumente in fokussierte Dateien
+\`\`\`
 
-*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
-`
-}
+**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)
 
-### 🎯 3-Schritt Erfolgsformel:
+## 🚀 BMAD Development Cycle (Phase 2)
 
-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
+### 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 ✅
 
-### 🆘 Hilfe:
+## 🆘 Help & Support
 
-- **\`/help\`** - Zeigt alle verfügbaren Kommandos
-- **\`/status\`** - Aktueller Projekt-Status
-- **\`/next\`** - Was ist der nächste Schritt?
+- \`/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
 
 ---
-*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*
+**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;
+    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...`));
-      
+
+      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 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 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);
+        fs.copyFileSync(sourcePath, targetPath);
       }
-      
+
       console.log(chalk.green(`    ✅ ${this.getIDEName(ide)} konfiguriert`));
     }
-    
+
     console.log(chalk.green("  ✅ Alle IDE-Integrationen abgeschlossen!"));
   }
 
@@ -696,45 +1833,58 @@ ${
     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")) {
+    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.yellow(`1. Ihre IDEs öffnen: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}`)
+        chalk.gray(`   → Agents sind bereits in allen IDEs installiert!\n`)
       );
-      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.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:"));
@@ -744,7 +1894,11 @@ ${
     );
     console.log(chalk.dim(`   • Projekt-Typ: ${this.config.projectType}`));
     console.log(
-      chalk.dim(`   • IDEs: ${this.config.selectedIDEs.map(ide => this.getIDEName(ide)).join(', ')}`)
+      chalk.dim(
+        `   • IDEs: ${this.config.selectedIDEs
+          .map((ide) => this.getIDEName(ide))
+          .join(", ")}`
+      )
     );
   }
 
@@ -753,8 +1907,8 @@ ${
     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
+        fs.existsSync(path.join(this.projectRoot, dir)) &&
+        fs.readdirSync(path.join(this.projectRoot, dir)).length > 0
     );
   }
 
@@ -780,7 +1934,7 @@ version: "1.0.0"
 project:
   type: ${this.config.projectType}
   created: ${new Date().toISOString()}
-  name: ${this.config.projectName || 'Unbenanntes Projekt'}
+  name: ${this.config.projectName || "Unbenanntes Projekt"}
   plan_approved: ${this.config.planApproved}
 
 # Wo die wichtigen Dateien liegen
@@ -807,21 +1961,25 @@ workflows:
 
 # IDE Integration (Mehrere IDEs)
 ides:
-${this.config.selectedIDEs.map(ide => `  - name: ${this.getIDEName(ide)}
+${this.config.selectedIDEs
+  .map(
+    (ide) => `  - name: ${this.getIDEName(ide)}
     config_path: ${this.getIDEConfig(ide).dir}
-    file_format: ${this.getIDEConfig(ide).suffix}`).join('\n')}
+    file_format: ${this.getIDEConfig(ide).suffix}`
+  )
+  .join("\n")}
 `;
   }
 }
 
-// Run installer if called directly  
+// 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);
+      installer.install().catch(console.error);
   } else {
     console.log(
       chalk.red("❌ Unknown command. Use: npx appiq-solution install")