@zeyue0329/xiaoma-cli 1.6.4 → 1.7.0

package/src/xmc/workflows/3-solutioning/xiaoma-create-architecture/steps/step-03-starter.md

@@ -0,0 +1,329 @@
+# Step 3: Starter Template Evaluation
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+- ✅ ALWAYS treat this as collaborative discovery between architectural peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on evaluating starter template options with current versions
+- 🌐 ALWAYS search the web to verify current versions - NEVER trust hardcoded versions
+- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete architecture
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 🌐 Search the web to verify current versions and options
+- ⚠️ Present A/P/C menu after generating starter template analysis
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to explore unconventional starter options or custom approaches
+- **P (Party Mode)**: Bring multiple perspectives to evaluate starter trade-offs for different use cases
+- **C (Continue)**: Save the content to the document and proceed to next step
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Invoke the `xiaoma-advanced-elicitation` skill
+- When 'P' selected: Invoke the `xiaoma-party-mode` skill
+- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Project context from step 2 is available and complete
+- Project context file from step-01 may contain technical preferences
+- No architectural decisions made yet - evaluating foundations
+- Focus on technical preferences discovery and starter evaluation
+- Consider project requirements and existing preferences when evaluating options
+
+## YOUR TASK:
+
+Discover technical preferences and evaluate starter template options, leveraging existing technical preferences and establishing solid architectural foundations.
+
+## STARTER EVALUATION SEQUENCE:
+
+### 0. Check Technical Preferences & Context
+
+**Check Project Context for Existing Technical Preferences:**
+"Before we dive into starter templates, let me check if you have any technical preferences already documented.
+
+{{if_project_context_exists}}
+I found some technical rules in your project context file:
+{{extracted_technical_preferences_from_project_context}}
+
+**Project Context Technical Rules Found:**
+
+- Languages/Frameworks: {{languages_frameworks_from_context}}
+- Tools & Libraries: {{tools_from_context}}
+- Development Patterns: {{patterns_from_context}}
+- Platform Preferences: {{platforms_from_context}}
+
+{{else}}
+No existing technical preferences found in project context file. We'll establish your technical preferences now.
+{{/if_project_context}}"
+
+**Discover User Technical Preferences:**
+"Based on your project context, let's discuss your technical preferences:
+
+{{primary_technology_category}} Preferences:
+
+- **Languages**: Do you have preferences between TypeScript/JavaScript, Python, Go, Rust, etc.?
+- **Frameworks**: Any existing familiarity or preferences (React, Vue, Angular, Next.js, etc.)?
+- **Databases**: Any preferences or existing infrastructure (PostgreSQL, MongoDB, MySQL, etc.)?
+
+**Development Experience:**
+
+- What's your team's experience level with different technologies?
+- Are there any technologies you want to learn vs. what you're comfortable with?
+
+**Platform/Deployment Preferences:**
+
+- Cloud provider preferences (AWS, Vercel, Railway, etc.)?
+- Container preferences (Docker, Serverless, Traditional)?
+
+**Integrations:**
+
+- Any existing systems or APIs you need to integrate with?
+- Third-party services you plan to use (payment, authentication, analytics, etc.)?
+
+These preferences will help me recommend the most suitable starter templates and guide our architectural decisions."
+
+### 1. Identify Primary Technology Domain
+
+Based on project context analysis and technical preferences, identify the primary technology stack:
+
+- **Web application** → Look for Next.js, Vite, Remix, SvelteKit starters
+- **Mobile app** → Look for React Native, Expo, Flutter starters
+- **API/Backend** → Look for NestJS, Express, Fastify, Supabase starters
+- **CLI tool** → Look for CLI framework starters (oclif, commander, etc.)
+- **Full-stack** → Look for T3, RedwoodJS, Blitz, Next.js starters
+- **Desktop** → Look for Electron, Tauri starters
+
+### 2. UX Requirements Consideration
+
+If UX specification was loaded, consider UX requirements when selecting starter:
+
+- **Rich animations** → Framer Motion compatible starter
+- **Complex forms** → React Hook Form included starter
+- **Real-time features** → Socket.io or WebSocket ready starter
+- **Design system** → Storybook-enabled starter
+- **Offline capability** → Service worker or PWA configured starter
+
+### 3. Research Current Starter Options
+
+Search the web to find current, maintained starter templates:
+
+```
+Search the web: "{{primary_technology}} starter template CLI create command latest"
+Search the web: "{{primary_technology}} boilerplate generator latest options"
+Search the web: "{{primary_technology}} production-ready starter best practices"
+```
+
+### 4. Investigate Top Starter Options
+
+For each promising starter found, investigate details:
+
+```
+Search the web: "{{starter_name}} default setup technologies included latest"
+Search the web: "{{starter_name}} project structure file organization"
+Search the web: "{{starter_name}} production deployment capabilities"
+Search the web: "{{starter_name}} recent updates maintenance status"
+```
+
+### 5. Analyze What Each Starter Provides
+
+For each viable starter option, document:
+
+**Technology Decisions Made:**
+
+- Language/TypeScript configuration
+- Styling solution (CSS, Tailwind, Styled Components, etc.)
+- Testing framework setup
+- Linting/Formatting configuration
+- Build tooling and optimization
+- Project structure and organization
+
+**Architectural Patterns Established:**
+
+- Code organization patterns
+- Component structure conventions
+- API layering approach
+- State management setup
+- Routing patterns
+- Environment configuration
+
+**Development Experience Features:**
+
+- Hot reloading and development server
+- TypeScript configuration
+- Debugging setup
+- Testing infrastructure
+- Documentation generation
+
+### 6. Present Starter Options
+
+Based on user skill level and project needs:
+
+**For Expert Users:**
+"Found {{starter_name}} which provides:
+{{quick_decision_list_of_key_decisions}}
+
+This would establish our base architecture with these technical decisions already made. Use it?"
+
+**For Intermediate Users:**
+"I found {{starter_name}}, which is a well-maintained starter for {{project_type}} projects.
+
+It makes these architectural decisions for us:
+{{decision_list_with_explanations}}
+
+This gives us a solid foundation following current best practices. Should we use it?"
+
+**For Beginner Users:**
+"I found {{starter_name}}, which is like a pre-built foundation for your project.
+
+Think of it like buying a prefab house frame instead of cutting each board yourself.
+
+It makes these decisions for us:
+{{friendly_explanation_of_decisions}}
+
+This is a great starting point that follows best practices and saves us from making dozens of small technical choices. Should we use it?"
+
+### 7. Get Current CLI Commands
+
+If user shows interest in a starter, get the exact current commands:
+
+```
+Search the web: "{{starter_name}} CLI command options flags latest"
+Search the web: "{{starter_name}} create new project command examples"
+```
+
+### 8. Generate Starter Template Content
+
+Prepare the content to append to the document:
+
+#### Content Structure:
+
+````markdown
+## Starter Template Evaluation
+
+### Primary Technology Domain
+
+{{identified_domain}} based on project requirements analysis
+
+### Starter Options Considered
+
+{{analysis_of_evaluated_starters}}
+
+### Selected Starter: {{starter_name}}
+
+**Rationale for Selection:**
+{{why_this_starter_was_chosen}}
+
+**Initialization Command:**
+
+```bash
+{{full_starter_command_with_options}}
+```
+
+**Architectural Decisions Provided by Starter:**
+
+**Language & Runtime:**
+{{language_typescript_setup}}
+
+**Styling Solution:**
+{{styling_solution_configuration}}
+
+**Build Tooling:**
+{{build_tools_and_optimization}}
+
+**Testing Framework:**
+{{testing_setup_and_configuration}}
+
+**Code Organization:**
+{{project_structure_and_patterns}}
+
+**Development Experience:**
+{{development_tools_and_workflow}}
+
+**Note:** Project initialization using this command should be the first implementation story.
+
+````
+
+### 9. Present Content and Menu
+
+Show the generated content and present choices:
+
+"I've analyzed starter template options for {{project_type}} projects.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 8]
+
+**What would you like to do?**
+[A] Advanced Elicitation - Explore custom approaches or unconventional starters
+[P] Party Mode - Evaluate trade-offs from different perspectives
+[C] Continue - Save this decision and move to architectural decisions"
+
+### 10. Handle Menu Selection
+
+#### If 'A' (Advanced Elicitation):
+
+- Invoke the `xiaoma-advanced-elicitation` skill with current starter analysis
+- Process enhanced insights about starter options or custom approaches
+- Ask user: "Accept these changes to the starter template evaluation? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'P' (Party Mode):
+
+- Invoke the `xiaoma-party-mode` skill with starter evaluation context
+- Process collaborative insights about starter trade-offs
+- Ask user: "Accept these changes to the starter template evaluation? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'C' (Continue):
+
+- Append the final content to `{planning_artifacts}/architecture.md`
+- Update frontmatter: `stepsCompleted: [1, 2, 3]`
+- Load `./step-04-decisions.md`
+
+## APPEND TO DOCUMENT:
+
+When user selects 'C', append the content directly to the document using the structure from step 8.
+
+## SUCCESS METRICS:
+
+✅ Primary technology domain correctly identified from project context
+✅ Current, maintained starter templates researched and evaluated
+✅ All versions verified using web search, not hardcoded
+✅ Architectural implications of starter choice clearly documented
+✅ User provided with clear rationale for starter selection
+✅ A/P/C menu presented and handled correctly
+✅ Content properly appended to document when C selected
+
+## FAILURE MODES:
+
+❌ Not verifying current versions with web search
+❌ Ignoring UX requirements when evaluating starters
+❌ Not documenting what architectural decisions the starter makes
+❌ Failing to consider maintenance status of starter templates
+❌ Not providing clear rationale for starter selection
+❌ Not presenting A/P/C menu after content generation
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
+
+## NEXT STEP:
+
+After user selects 'C' and content is saved to document, load `./step-04-decisions.md` to begin making specific architectural decisions.
+
+Remember: Do NOT proceed to step-04 until user explicitly selects 'C' from the A/P/C menu and content is saved!

package/src/xmc/workflows/3-solutioning/xiaoma-create-architecture/steps/step-04-decisions.md

@@ -0,0 +1,318 @@
+# Step 4: Core Architectural Decisions
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate content without user input
+
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
+- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
+- ✅ ALWAYS treat this as collaborative discovery between architectural peers
+- 📋 YOU ARE A FACILITATOR, not a content generator
+- 💬 FOCUS on making critical architectural decisions collaboratively
+- 🌐 ALWAYS search the web to verify current technology versions
+- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Show your analysis before taking any action
+- 🌐 Search the web to verify technology versions and options
+- ⚠️ Present A/P/C menu after each major decision category
+- 💾 ONLY save when user chooses C (Continue)
+- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## COLLABORATION MENUS (A/P/C):
+
+This step will generate content and present choices for each decision category:
+
+- **A (Advanced Elicitation)**: Use discovery protocols to explore innovative approaches to specific decisions
+- **P (Party Mode)**: Bring multiple perspectives to evaluate decision trade-offs
+- **C (Continue)**: Save the current decisions and proceed to next decision category
+
+## PROTOCOL INTEGRATION:
+
+- When 'A' selected: Invoke the `xiaoma-advanced-elicitation` skill
+- When 'P' selected: Invoke the `xiaoma-party-mode` skill
+- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
+- User accepts/rejects protocol changes before proceeding
+
+## CONTEXT BOUNDARIES:
+
+- Project context from step 2 is available
+- Starter template choice from step 3 is available
+- Project context file may contain technical preferences and rules
+- Technical preferences discovered in step 3 are available
+- Focus on decisions not already made by starter template or existing preferences
+- Collaborative decision making, not recommendations
+
+## YOUR TASK:
+
+Facilitate collaborative architectural decision making, leveraging existing technical preferences and starter template decisions, focusing on remaining choices critical to the project's success.
+
+## DECISION MAKING SEQUENCE:
+
+### 1. Load Decision Framework & Check Existing Preferences
+
+**Review Technical Preferences from Step 3:**
+"Based on our technical preferences discussion in step 3, let's build on those foundations:
+
+**Your Technical Preferences:**
+{{user_technical_preferences_from_step_3}}
+
+**Starter Template Decisions:**
+{{starter_template_decisions}}
+
+**Project Context Technical Rules:**
+{{project_context_technical_rules}}"
+
+**Identify Remaining Decisions:**
+Based on technical preferences, starter template choice, and project context, identify remaining critical decisions:
+
+**Already Decided (Don't re-decide these):**
+
+- {{starter_template_decisions}}
+- {{user_technology_preferences}}
+- {{project_context_technical_rules}}
+
+**Critical Decisions:** Must be decided before implementation can proceed
+**Important Decisions:** Shape the architecture significantly
+**Nice-to-Have:** Can be deferred if needed
+
+### 2. Decision Categories by Priority
+
+#### Category 1: Data Architecture
+
+- Database choice (if not determined by starter)
+- Data modeling approach
+- Data validation strategy
+- Migration approach
+- Caching strategy
+
+#### Category 2: Authentication & Security
+
+- Authentication method
+- Authorization patterns
+- Security middleware
+- Data encryption approach
+- API security strategy
+
+#### Category 3: API & Communication
+
+- API design patterns (REST, GraphQL, etc.)
+- API documentation approach
+- Error handling standards
+- Rate limiting strategy
+- Communication between services
+
+#### Category 4: Frontend Architecture (if applicable)
+
+- State management approach
+- Component architecture
+- Routing strategy
+- Performance optimization
+- Bundle optimization
+
+#### Category 5: Infrastructure & Deployment
+
+- Hosting strategy
+- CI/CD pipeline approach
+- Environment configuration
+- Monitoring and logging
+- Scaling strategy
+
+### 3. Facilitate Each Decision Category
+
+For each category, facilitate collaborative decision making:
+
+**Present the Decision:**
+Based on user skill level and project context:
+
+**Expert Mode:**
+"{{Decision_Category}}: {{Specific_Decision}}
+
+Options: {{concise_option_list_with_tradeoffs}}
+
+What's your preference for this decision?"
+
+**Intermediate Mode:**
+"Next decision: {{Human_Friendly_Category}}
+
+We need to choose {{Specific_Decision}}.
+
+Common options:
+{{option_list_with_brief_explanations}}
+
+For your project, I'd lean toward {{recommendation}} because {{reason}}. What are your thoughts?"
+
+**Beginner Mode:**
+"Let's talk about {{Human_Friendly_Category}}.
+
+{{Educational_Context_About_Why_This_Matters}}
+
+Think of it like {{real_world_analogy}}.
+
+Your main options:
+{{friendly_options_with_pros_cons}}
+
+My suggestion: {{recommendation}}
+This is good for you because {{beginner_friendly_reason}}.
+
+What feels right to you?"
+
+**Verify Technology Versions:**
+If decision involves specific technology:
+
+```
+Search the web: "{{technology}} latest stable version"
+Search the web: "{{technology}} current LTS version"
+Search the web: "{{technology}} production readiness"
+```
+
+**Get User Input:**
+"What's your preference? (or 'explain more' for details)"
+
+**Handle User Response:**
+
+- If user wants more info: Provide deeper explanation
+- If user has preference: Discuss implications and record decision
+- If user wants alternatives: Explore other options
+
+**Record the Decision:**
+
+- Category: {{category}}
+- Decision: {{user_choice}}
+- Version: {{verified_version_if_applicable}}
+- Rationale: {{user_reasoning_or_default}}
+- Affects: {{components_or_epics}}
+- Provided by Starter: {{yes_if_from_starter}}
+
+### 4. Check for Cascading Implications
+
+After each major decision, identify related decisions:
+
+"This choice means we'll also need to decide:
+
+- {{related_decision_1}}
+- {{related_decision_2}}"
+
+### 5. Generate Decisions Content
+
+After facilitating all decision categories, prepare the content to append:
+
+#### Content Structure:
+
+```markdown
+## Core Architectural Decisions
+
+### Decision Priority Analysis
+
+**Critical Decisions (Block Implementation):**
+{{critical_decisions_made}}
+
+**Important Decisions (Shape Architecture):**
+{{important_decisions_made}}
+
+**Deferred Decisions (Post-MVP):**
+{{decisions_deferred_with_rationale}}
+
+### Data Architecture
+
+{{data_related_decisions_with_versions_and_rationale}}
+
+### Authentication & Security
+
+{{security_related_decisions_with_versions_and_rationale}}
+
+### API & Communication Patterns
+
+{{api_related_decisions_with_versions_and_rationale}}
+
+### Frontend Architecture
+
+{{frontend_related_decisions_with_versions_and_rationale}}
+
+### Infrastructure & Deployment
+
+{{infrastructure_related_decisions_with_versions_and_rationale}}
+
+### Decision Impact Analysis
+
+**Implementation Sequence:**
+{{ordered_list_of_decisions_for_implementation}}
+
+**Cross-Component Dependencies:**
+{{how_decisions_affect_each_other}}
+```
+
+### 6. Present Content and Menu
+
+Show the generated decisions content and present choices:
+
+"I've documented all the core architectural decisions we've made together.
+
+**Here's what I'll add to the document:**
+
+[Show the complete markdown content from step 5]
+
+**What would you like to do?**
+[A] Advanced Elicitation - Explore innovative approaches to any specific decisions
+[P] Party Mode - Review decisions from multiple perspectives
+[C] Continue - Save these decisions and move to implementation patterns"
+
+### 7. Handle Menu Selection
+
+#### If 'A' (Advanced Elicitation):
+
+- Invoke the `xiaoma-advanced-elicitation` skill with specific decision categories
+- Process enhanced insights about particular decisions
+- Ask user: "Accept these enhancements to the architectural decisions? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'P' (Party Mode):
+
+- Invoke the `xiaoma-party-mode` skill with architectural decisions context
+- Process collaborative insights about decision trade-offs
+- Ask user: "Accept these changes to the architectural decisions? (y/n)"
+- If yes: Update content, then return to A/P/C menu
+- If no: Keep original content, then return to A/P/C menu
+
+#### If 'C' (Continue):
+
+- Append the final content to `{planning_artifacts}/architecture.md`
+- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
+- Load `./step-05-patterns.md`
+
+## APPEND TO DOCUMENT:
+
+When user selects 'C', append the content directly to the document using the structure from step 5.
+
+## SUCCESS METRICS:
+
+✅ All critical architectural decisions made collaboratively
+✅ Technology versions verified using web search
+✅ Decision rationale clearly documented
+✅ Cascading implications identified and addressed
+✅ User provided appropriate level of explanation for skill level
+✅ A/P/C menu presented and handled correctly for each category
+✅ Content properly appended to document when C selected
+
+## FAILURE MODES:
+
+❌ Making recommendations instead of facilitating decisions
+❌ Not verifying technology versions with web search
+❌ Missing cascading implications between decisions
+❌ Not adapting explanations to user skill level
+❌ Forgetting to document decisions made by starter template
+❌ Not presenting A/P/C menu after content generation
+
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
+❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
+❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
+
+## NEXT STEP:
+
+After user selects 'C' and content is saved to document, load `./step-05-patterns.md` to define implementation patterns that ensure consistency across AI agents.
+
+Remember: Do NOT proceed to step-05 until user explicitly selects 'C' from the A/P/C menu and content is saved!