@zeyue0329/xiaoma-cli 1.0.49 → 1.0.66

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-07-create-architecture.md

@@ -0,0 +1,107 @@
+---
+name: "step-07-create-architecture"
+description: "Architect role creates technical architecture design by delegating to create-architecture workflow"
+nextStepFile: "./step-08-finalize.md"
+---
+
+# Step 7 of 8: Create Architecture Design
+
+**Goal:** Design the technical architecture for the new features/requirements, integrating with the existing codebase architecture. Delegates to the existing create-architecture workflow.
+
+**Role:** Architect (xiaojia) — Technical Architect + Systems Design Expert
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Switch to Architect Role
+
+Adopt the Architect (xiaojia) persona:
+
+- You are xiaojia, the Technical Architect + Systems Design Expert
+- Your purpose is to design an architecture that integrates new requirements cleanly with the existing system
+- Focus on incremental, pragmatic design that respects existing patterns
+
+### 2. Load Required Context
+
+Load these artifacts in order:
+
+1. **PRIMARY SOURCE** — Read the FULL file from beginning to end
+   - File: `{planning_artifacts}/prd.md` (validated PRD)
+   - Requirement: Complete read, no skipping
+
+2. **SECONDARY SOURCES** — Read each file fully if it exists
+   - File: `{planning_artifacts}/epics.md` (epic and story breakdown) — Required
+   - File: `{planning_artifacts}/current-architecture-analysis.md` (from Step 3) — Required
+   - File: `{planning_artifacts}/requirements-analysis.md` (from Step 2) — Required
+
+### 3. Verify Workflow Prerequisites
+
+Before delegating, verify the required workflow exists:
+
+1. Check that `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-architecture/workflow.md` is readable
+2. If workflow is missing:
+   - HALT — "Required workflow not found: `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-architecture/workflow.md`. Verify XiaoMa installation is complete."
+
+### 4. Execute Architecture Design (Delegate)
+
+Invoke the `xiaoma-create-architecture` skill to design the technical architecture.
+
+**CRITICAL PIPELINE MODE INSTRUCTIONS:**
+
+- This is running in **automated pipeline mode** — do NOT pause for user input
+- The create-architecture workflow has 9 step files: init → (continue) → context → starter → decisions → patterns → structure → validation → complete
+- **IMPORTANT DISTINCTION:** Step 3 of this pipeline creates `current-architecture-analysis.md` (analysis of the *existing* codebase), NOT `architecture.md` (the *new* design document). Therefore `architecture.md` should NOT already exist when step-07 runs. If `architecture.md` IS found unexpectedly (e.g., from a prior partial run), treat it as a stale artifact and let the workflow overwrite/recreate it fresh
+- Step 1 (init) of create-architecture detects existing workflow state — if `architecture.md` already exists unexpectedly, it may branch to step-01b-continue.md — in that case, automatically select **O (Overwrite)** to start fresh
+- Step 1b (continue) presents a menu with R/C/O/X options — if reached due to a stale artifact, automatically select **O (Overwrite)** for a clean pipeline run
+- When ANY step presents a menu with **[C] Continue**, automatically select **C** to proceed to the next step
+- Step 1 asks user to confirm discovered documents — automatically confirm and select **C**
+- When the workflow asks for architectural decisions, make pragmatic choices based on the existing architecture analysis
+- Prefer incremental changes over greenfield redesigns
+- Ensure the architecture aligns with existing patterns and conventions
+- Consider the technology stack identified in Step 3
+- Output file MUST be: `{planning_artifacts}/architecture.md`
+
+### 5. Verify Architecture Output
+
+After create-architecture workflow completes:
+
+1. Verify `{planning_artifacts}/architecture.md` exists
+2. Verify the architecture addresses all epics from the PRD
+3. Verify it accounts for existing system patterns and conventions
+4. Verify it includes implementation guidance
+
+If architecture creation failed:
+
+- HALT — "Architecture design failed. Check PRD, epics, and existing architecture analysis."
+
+### 6. Pipeline Status Update
+
+- Set `{pipeline_status}` = "architecture-created"
+- Set `{steps_completed}` = 7
+- Output: "Architecture design complete at `{planning_artifacts}/architecture.md`. Proceeding to finalization."
+
+**Automatically proceed to next step — do NOT wait for user input.**
+
+---
+
+## NEXT STEP
+
+**NEXT:** Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-08-finalize.md`
+
+---
+
+## SUCCESS METRICS
+
+- `{planning_artifacts}/architecture.md` created with complete technical design
+- Architecture addresses all epics and PRD features
+- Design is compatible with existing system architecture
+- Implementation guidance provided
+- Technology choices justified
+
+## FAILURE MODES
+
+- Architecture incompatible with existing system
+- Missing coverage for PRD features
+- Over-engineering or unnecessary greenfield redesign
+- Not writing output file

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-08-finalize.md

@@ -0,0 +1,124 @@
+---
+name: "step-08-finalize"
+description: "Generate completion report, validate all artifacts, and provide next-step guidance"
+nextStepFile: null
+---
+
+# Step 8 of 8: Finalize Pipeline
+
+**Goal:** Validate all output artifacts exist, generate a completion report, and provide guidance on next steps.
+
+**Role:** Pipeline Orchestrator
+
+---
+
+## EXECUTION SEQUENCE
+
+### 1. Validate All Artifacts
+
+Check that ALL required output files exist:
+
+1. **Requirements Analysis** — `{planning_artifacts}/requirements-analysis.md`
+2. **Architecture Analysis** — `{planning_artifacts}/current-architecture-analysis.md`
+3. **PRD** — `{planning_artifacts}/prd.md`
+4. **Epics** — `{planning_artifacts}/epics.md`
+5. **Architecture Design** — `{planning_artifacts}/architecture.md`
+
+For each missing artifact, log a warning. If PRD or Epics are missing, this is a critical failure.
+
+### 2. Run Completion Checklist
+
+Load and evaluate: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/checklist.md`
+
+Mark each item as passed or failed based on artifact verification.
+
+### 3. Generate Completion Report
+
+Set `{steps_completed}` = 8 and `{pipeline_status}` = "complete" now, before printing, so the report reflects the final accurate values.
+
+**Output:**
+
+```
+═══════════════════════════════════════════════════
+  Auto Requirements Pipeline — COMPLETE
+═══════════════════════════════════════════════════
+
+Project: {project_name}
+Date: {date}
+Steps Completed: {steps_completed}/8
+
+📄 Output Artifacts:
+  ✅/❌ {planning_artifacts}/requirements-analysis.md
+  ✅/❌ {planning_artifacts}/current-architecture-analysis.md
+  ✅/❌ {planning_artifacts}/prd.md
+  ✅/❌ {planning_artifacts}/epics.md
+  ✅/❌ {planning_artifacts}/architecture.md
+
+Pipeline Status: {pipeline_status}
+
+═══════════════════════════════════════════════════
+```
+
+### 4. Generate Machine-Readable Status File
+
+Write machine-readable status to: `{planning_artifacts}/pipeline-status.json`
+
+```json
+{
+  "pipeline": "auto-requirements-pipeline",
+  "date": "{date}",
+  "project": "{project_name}",
+  "status": "complete",
+  "steps_completed": 8,
+  "artifacts": {
+    "requirements_analysis": "{planning_artifacts}/requirements-analysis.md",
+    "architecture_analysis": "{planning_artifacts}/current-architecture-analysis.md",
+    "prd": "{planning_artifacts}/prd.md",
+    "epics": "{planning_artifacts}/epics.md",
+    "architecture": "{planning_artifacts}/architecture.md"
+  },
+  "iterations": {
+    "analysis": {analysis_iteration},
+    "architecture": {architecture_iteration},
+    "validation": {validation_iteration}
+  }
+}
+```
+
+This enables downstream tools (including the Auto Story Pipeline) to check pipeline status programmatically.
+
+### 5. Provide Next Steps
+
+**Output:**
+
+```
+🔜 Recommended Next Steps:
+
+1. Review generated artifacts in {planning_artifacts}/
+2. Run Sprint Planning (SP) to organize stories into sprints
+3. Run Auto Story Pipeline to begin implementation
+
+Available commands:
+  - SP (Sprint Planning) — Organize epics/stories into sprints
+  - ASP (Auto Story Pipeline) — Automated story development lifecycle
+```
+
+### 6. Pipeline Complete
+
+**Pipeline execution is COMPLETE. HALT.**
+
+---
+
+## SUCCESS METRICS
+
+- All 5 output artifacts verified
+- Machine-readable `pipeline-status.json` generated
+- Completion report generated
+- Next steps provided
+- Pipeline status set to "complete"
+
+## FAILURE MODES
+
+- Missing critical artifacts (PRD, Epics)
+- Not providing completion report
+- Not suggesting next steps

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/workflow.md

@@ -0,0 +1,107 @@
+---
+name: auto-requirements-pipeline
+description: "Automated end-to-end requirements analysis pipeline: requirements analysis → architecture analysis → PRD creation → PRD validation → epic+story creation → architecture design → finalize. Use when the user says 'auto requirements', 'run requirements pipeline', or 'AR'"
+---
+
+# Auto Requirements Pipeline Workflow
+
+**Goal:** Execute the complete automated requirements analysis lifecycle — from requirements document (req.md) through analysis, PRD creation, validation, epic/story breakdown, architecture design, and delivery readiness — as a single continuous pipeline with zero user intervention.
+
+**Your Role:** Pipeline Orchestrator. You switch expert roles at each phase:
+
+- **Analyst (xiaofen)** — Requirements analysis and deep research
+- **Architect (xiaojia)** — Architecture analysis and design
+- **PM (xiaochan)** — PRD creation, validation, and epic/story breakdown
+
+- Communicate all responses in {communication_language} and generate all documents in {document_output_language}
+- Execute ALL steps in exact order; do NOT skip steps
+- Absolutely DO NOT stop because of "milestones", "significant progress", or "session boundaries". Continue in a single execution until the pipeline is COMPLETE or a HALT condition is triggered
+- Each step file loads fresh to combat "lost in the middle" context degradation
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for focused execution across a long-running pipeline:
+
+- Each step loads fresh to prevent context loss in long sessions
+- State persists via variables passed between steps
+- Sequential progression through pipeline phases with conditional branching
+- Role switching at each phase boundary
+
+### State Variables
+
+- `{req_file_path}` — Path to the requirements document (default: `{planning_artifacts}/req.md`)
+- `{pipeline_status}` — Current pipeline phase for tracking
+- `{steps_completed}` — Count of steps completed in this pipeline run
+- `{validation_iteration}` — PRD validation loop counter (used in step-05, max 3)
+- `{max_validation_iterations}` — PRD validation retry limit (set in step-05, default 3; higher than analysis/architecture limits because PRD validation delegates to the full 14-step validate-prd workflow)
+- `{analysis_iteration}` — Requirements analysis quality-retry counter (used in step-02, max 2 retries)
+- `{architecture_iteration}` — Architecture analysis quality-retry counter (used in step-03, max 2 retries)
+
+### Output Artifacts
+
+All outputs are written to `{planning_artifacts}/`:
+
+- `requirements-analysis.md` — Deep requirements analysis report
+- `current-architecture-analysis.md` — Existing codebase architecture analysis
+- `prd.md` — Product Requirements Document
+- `epics.md` — Epic and story breakdown
+- `architecture.md` — Technical architecture design
+- `pipeline-status.json` — Machine-readable pipeline completion status
+
+### Architecture Document Types (Important Distinction)
+
+This pipeline produces TWO different architecture documents:
+
+1. **current-architecture-analysis.md** (Step 3 output)
+   - Analysis of the EXISTING codebase
+   - Generated by Architect (xiaojia) analyzing current system patterns
+   - Used as context for designing new features that integrate cleanly
+   - Describes what IS
+
+2. **architecture.md** (Step 7 output)
+   - Technical design for NEW features/requirements
+   - Generated by Architect (xiaojia) designing the solution
+   - References current architecture analysis as context
+   - Describes what SHOULD BE
+
+When step-07 runs, it may find a stale `architecture.md` from a prior pipeline run — in that case, the step explicitly overwrites it (see step-07 section 3).
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_xiaoma/xmc/config.yaml` and resolve:
+
+- `project_name`, `user_name`
+- `communication_language`, `document_output_language`
+- `user_skill_level`
+- `planning_artifacts`, `implementation_artifacts`
+- `date` as system-generated current datetime
+
+### Paths
+
+- `installed_path` = `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline`
+- `validation` = `{installed_path}/checklist.md`
+
+### Related Workflows
+
+These existing workflows contain the detailed logic that pipeline steps delegate to:
+
+- `create_prd_workflow` = `{project-root}/_xiaoma/core/tasks/xiaoma-create-prd/workflow.md` *(Note: uses `core/tasks/` path — `xiaoma-create-prd` originates in the core module, not the xmc module. All other related workflows use `_xiaoma/xmc/workflows/`.)*
+- `validate_prd_workflow` = `{project-root}/_xiaoma/xmc/workflows/2-plan-workflows/xiaoma-validate-prd/workflow.md`
+- `create_epics_workflow` = `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-epics-and-stories/workflow.md`
+- `create_architecture_workflow` = `{project-root}/_xiaoma/xmc/workflows/3-solutioning/xiaoma-create-architecture/workflow.md`
+
+### Context
+
+- `project_context` = `**/project-context.md` (load if exists)
+
+---
+
+## EXECUTION
+
+Read fully and follow: `{project-root}/_xiaoma/xmc/workflows/1-analysis/auto-requirements-pipeline/steps/step-01-init-and-validate.md` to begin the pipeline.

package/src/xmc/workflows/1-analysis/auto-requirements-pipeline/xiaoma-skill-manifest.yaml

@@ -0,0 +1,3 @@
+canonicalId: xiaoma-auto-requirements-pipeline
+type: workflow
+description: "Automated requirements analysis pipeline: analyze → PRD → validate → epics → architecture → ready. Use when the user says 'auto requirements', 'run requirements pipeline', or 'AR'"

package/src/xmc/workflows/1-analysis/research/market-steps/step-01-init.md

@@ -0,0 +1,182 @@
+# Market Research Step 1: Market Research Initialization
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+- 🛑 NEVER generate research content in init step
+- ✅ ALWAYS confirm understanding of user's research goals
+- 📋 YOU ARE A MARKET RESEARCH FACILITATOR, not content generator
+- 💬 FOCUS on clarifying scope and approach
+- 🔍 NO WEB RESEARCH in init - that's for later steps
+- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete research
+- 🔄 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:
+
+- 🎯 Confirm research understanding before proceeding
+- ⚠️ Present [C] continue option after scope clarification
+- 💾 Write initial scope document immediately
+- 📖 Update frontmatter `stepsCompleted: [1]` before loading next step
+- 🚫 FORBIDDEN to load next step until C is selected
+
+## CONTEXT BOUNDARIES:
+
+- Current document and frontmatter from main workflow discovery are available
+- Research type = "market" is already set
+- **Research topic = "{{research_topic}}"** - discovered from initial discussion
+- **Research goals = "{{research_goals}}"** - captured from initial discussion
+- Focus on market research scope clarification
+- Web search capabilities are enabled for later steps
+
+## YOUR TASK:
+
+Initialize market research by confirming understanding of {{research_topic}} and establishing clear research scope.
+
+## MARKET RESEARCH INITIALIZATION:
+
+### 1. Confirm Research Understanding
+
+**INITIALIZE - DO NOT RESEARCH YET**
+
+Start with research confirmation:
+"I understand you want to conduct **market research** for **{{research_topic}}** with these goals: {{research_goals}}
+
+**My Understanding of Your Research Needs:**
+
+- **Research Topic**: {{research_topic}}
+- **Research Goals**: {{research_goals}}
+- **Research Type**: Market Research
+- **Approach**: Comprehensive market analysis with source verification
+
+**Market Research Areas We'll Cover:**
+
+- Market size, growth dynamics, and trends
+- Customer insights and behavior analysis
+- Competitive landscape and positioning
+- Strategic recommendations and implementation guidance
+
+**Does this accurately capture what you're looking for?**"
+
+### 2. Refine Research Scope
+
+Gather any clarifications needed:
+
+#### Scope Clarification Questions:
+
+- "Are there specific customer segments or aspects of {{research_topic}} we should prioritize?"
+- "Should we focus on specific geographic regions or global market?"
+- "Is this for market entry, expansion, product development, or other business purpose?"
+- "Any competitors or market segments you specifically want us to analyze?"
+
+### 3. Document Initial Scope
+
+**WRITE IMMEDIATELY TO DOCUMENT**
+
+Write initial research scope to document:
+
+```markdown
+# Market Research: {{research_topic}}
+
+## Research Initialization
+
+### Research Understanding Confirmed
+
+**Topic**: {{research_topic}}
+**Goals**: {{research_goals}}
+**Research Type**: Market Research
+**Date**: {{date}}
+
+### Research Scope
+
+**Market Analysis Focus Areas:**
+
+- Market size, growth projections, and dynamics
+- Customer segments, behavior patterns, and insights
+- Competitive landscape and positioning analysis
+- Strategic recommendations and implementation guidance
+
+**Research Methodology:**
+
+- Current web data with source verification
+- Multiple independent sources for critical claims
+- Confidence level assessment for uncertain data
+- Comprehensive coverage with no critical gaps
+
+### Next Steps
+
+**Research Workflow:**
+
+1. ✅ Initialization and scope setting (current step)
+2. Customer Insights and Behavior Analysis
+3. Competitive Landscape Analysis
+4. Strategic Synthesis and Recommendations
+
+**Research Status**: Scope confirmed, ready to proceed with detailed market analysis
+```
+
+### 4. Present Confirmation and Continue Option
+
+Show initial scope document and present continue option:
+"I've documented our understanding and initial scope for **{{research_topic}}** market research.
+
+**What I've established:**
+
+- Research topic and goals confirmed
+- Market analysis focus areas defined
+- Research methodology verification
+- Clear workflow progression
+
+**Document Status:** Initial scope written to research file for your review
+
+**Ready to begin detailed market research?**
+[C] Continue - Confirm scope and proceed to customer insights analysis
+[Modify] Suggest changes to research scope before proceeding
+
+### 5. Handle User Response
+
+#### If 'C' (Continue):
+
+- Update frontmatter: `stepsCompleted: [1]`
+- Add confirmation note to document: "Scope confirmed by user on {{date}}"
+- Load: `{project-root}/_xiaoma/xmc/workflows/1-analysis/research/market-steps/step-02-customer-behavior.md`
+
+#### If 'Modify':
+
+- Gather user changes to scope
+- Update document with modifications
+- Re-present updated scope for confirmation
+
+## SUCCESS METRICS:
+
+✅ Research topic and goals accurately understood
+✅ Market research scope clearly defined
+✅ Initial scope document written immediately
+✅ User opportunity to review and modify scope
+✅ [C] continue option presented and handled correctly
+✅ Document properly updated with scope confirmation
+
+## FAILURE MODES:
+
+❌ Not confirming understanding of research topic and goals
+❌ Generating research content instead of just scope clarification
+❌ Not writing initial scope document to file
+❌ Not providing opportunity for user to modify scope
+❌ Proceeding to next step without user confirmation
+❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor research 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
+
+## INITIALIZATION PRINCIPLES:
+
+This step ensures:
+
+- Clear mutual understanding of research objectives
+- Well-defined research scope and approach
+- Immediate documentation for user review
+- User control over research direction before detailed work begins
+
+## NEXT STEP:
+
+After user confirmation and scope finalization, load `{project-root}/_xiaoma/xmc/workflows/1-analysis/research/market-steps/step-02-customer-behavior.md` to begin detailed market research with customer insights analysis.
+
+Remember: Init steps confirm understanding and scope, not generate research content!