@zeyue0329/xiaoma-cli 1.0.49 → 1.6.5

package/src/xmc/module-help.csv

@@ -0,0 +1,32 @@
+module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs,
+xmc,anytime,Document Project,DP,,_xiaoma/xmc/workflows/document-project/workflow.md,xiaoma-xmc-document-project,false,analyst,Create Mode,"Analyze an existing project to produce useful documentation",project-knowledge,*,
+xmc,anytime,Generate Project Context,GPC,,_xiaoma/xmc/workflows/generate-project-context/workflow.md,xiaoma-xmc-generate-project-context,false,analyst,Create Mode,"Scan existing codebase to generate a lean LLM-optimized project-context.md containing critical implementation rules patterns and conventions for AI agents. Essential for brownfield projects and quick-flow.",output_folder,"project context",
+xmc,anytime,Quick Spec,QS,,_xiaoma/xmc/workflows/xiaoma-quick-flow/quick-spec/workflow.md,xiaoma-xmc-quick-spec,false,quick-flow-solo-dev,Create Mode,"Do not suggest for potentially very complex things unless requested or if the user complains that they do not want to follow the extensive planning of the xiaoma method. Quick one-off tasks small changes simple apps brownfield additions to well established patterns utilities without extensive planning",planning_artifacts,"tech spec",
+xmc,anytime,Quick Dev,QD,,_xiaoma/xmc/workflows/xiaoma-quick-flow/quick-dev/workflow.md,xiaoma-xmc-quick-dev,false,quick-flow-solo-dev,Create Mode,"Quick one-off tasks small changes simple apps utilities without extensive planning - Do not suggest for potentially very complex things unless requested or if the user complains that they do not want to follow the extensive planning of the xiaoma method, unless the user is already working through the implementation phase and just requests a 1 off things not already in the plan",,,
+xmc,anytime,Quick Dev New Preview,QQ,,skill:xiaoma-quick-dev-new-preview,xiaoma-xmc-quick-dev-new-preview,false,quick-flow-solo-dev,Create Mode,"Unified quick flow (experimental): clarify intent plan implement review and present in a single workflow",implementation_artifacts,"tech spec implementation",
+xmc,anytime,Correct Course,CC,,_xiaoma/xmc/workflows/4-implementation/correct-course/workflow.md,xiaoma-xmc-correct-course,false,sm,Create Mode,"Anytime: Navigate significant changes. May recommend start over update PRD redo architecture sprint planning or correct epics and stories",planning_artifacts,"change proposal",
+xmc,anytime,Write Document,WD,,_xiaoma/xmc/agents/tech-writer/tech-writer.agent.yaml,,false,tech-writer,,"Describe in detail what you want, and the agent will follow the documentation best practices defined in agent memory. Multi-turn conversation with subprocess for research/review.",project-knowledge,"document",
+xmc,anytime,Update Standards,US,,_xiaoma/xmc/agents/tech-writer/tech-writer.agent.yaml,,false,tech-writer,,"Update agent memory documentation-standards.md with your specific preferences if you discover missing document conventions.",_xiaoma/_memory/tech-writer-sidecar,"standards",
+xmc,anytime,Mermaid Generate,MG,,_xiaoma/xmc/agents/tech-writer/tech-writer.agent.yaml,,false,tech-writer,,"Create a Mermaid diagram based on user description. Will suggest diagram types if not specified.",planning_artifacts,"mermaid diagram",
+xmc,anytime,Validate Document,VD,,_xiaoma/xmc/agents/tech-writer/tech-writer.agent.yaml,,false,tech-writer,,"Review the specified document against documentation standards and best practices. Returns specific actionable improvement suggestions organized by priority.",planning_artifacts,"validation report",
+xmc,anytime,Explain Concept,EC,,_xiaoma/xmc/agents/tech-writer/tech-writer.agent.yaml,,false,tech-writer,,"Create clear technical explanations with examples and diagrams for complex concepts. Breaks down into digestible sections using task-oriented approach.",project_knowledge,"explanation",
+xmc,1-analysis,Brainstorm Project,BP,10,_xiaoma/core/workflows/brainstorming/workflow.md,xiaoma-brainstorming,false,analyst,data=_xiaoma/xmc/data/project-context-template.md,"Expert Guided Facilitation through a single or multiple techniques",planning_artifacts,"brainstorming session",
+xmc,1-analysis,Market Research,MR,20,_xiaoma/xmc/workflows/1-analysis/research/workflow-market-research.md,xiaoma-xmc-market-research,false,analyst,Create Mode,"Market analysis competitive landscape customer needs and trends","planning_artifacts|project-knowledge","research documents",
+xmc,1-analysis,Domain Research,DR,21,_xiaoma/xmc/workflows/1-analysis/research/workflow-domain-research.md,xiaoma-xmc-domain-research,false,analyst,Create Mode,"Industry domain deep dive subject matter expertise and terminology","planning_artifacts|project_knowledge","research documents",
+xmc,1-analysis,Technical Research,TR,22,_xiaoma/xmc/workflows/1-analysis/research/workflow-technical-research.md,xiaoma-xmc-technical-research,false,analyst,Create Mode,"Technical feasibility architecture options and implementation approaches","planning_artifacts|project_knowledge","research documents",
+xmc,1-analysis,Create Brief,CB,30,_xiaoma/xmc/workflows/1-analysis/create-product-brief/workflow.md,xiaoma-xmc-create-product-brief,false,analyst,Create Mode,"A guided experience to nail down your product idea",planning_artifacts,"product brief",
+xmc,2-planning,Create PRD,CP,10,_xiaoma/xmc/workflows/2-plan-workflows/create-prd/workflow-create-prd.md,xiaoma-xmc-create-prd,true,pm,Create Mode,"Expert led facilitation to produce your Product Requirements Document",planning_artifacts,prd,
+xmc,2-planning,Validate PRD,VP,20,_xiaoma/xmc/workflows/2-plan-workflows/create-prd/workflow-validate-prd.md,xiaoma-xmc-validate-prd,false,pm,Validate Mode,"Validate PRD is comprehensive lean well organized and cohesive",planning_artifacts,"prd validation report",
+xmc,2-planning,Edit PRD,EP,25,_xiaoma/xmc/workflows/2-plan-workflows/create-prd/workflow-edit-prd.md,xiaoma-xmc-edit-prd,false,pm,Edit Mode,"Improve and enhance an existing PRD",planning_artifacts,"updated prd",
+xmc,2-planning,Create UX,CU,30,_xiaoma/xmc/workflows/2-plan-workflows/create-ux-design/workflow.md,xiaoma-xmc-create-ux-design,false,ux-designer,Create Mode,"Guidance through realizing the plan for your UX, strongly recommended if a UI is a primary piece of the proposed project",planning_artifacts,"ux design",
+xmc,3-solutioning,Create Architecture,CA,10,_xiaoma/xmc/workflows/3-solutioning/create-architecture/workflow.md,xiaoma-xmc-create-architecture,true,architect,Create Mode,"Guided Workflow to document technical decisions",planning_artifacts,architecture,
+xmc,3-solutioning,Create Epics and Stories,CE,30,_xiaoma/xmc/workflows/3-solutioning/create-epics-and-stories/workflow.md,xiaoma-xmc-create-epics-and-stories,true,pm,Create Mode,"Create the Epics and Stories Listing",planning_artifacts,"epics and stories",
+xmc,3-solutioning,Check Implementation Readiness,IR,70,_xiaoma/xmc/workflows/3-solutioning/check-implementation-readiness/workflow.md,xiaoma-xmc-check-implementation-readiness,true,architect,Validate Mode,"Ensure PRD UX Architecture and Epics Stories are aligned",planning_artifacts,"readiness report",
+xmc,4-implementation,Sprint Planning,SP,10,_xiaoma/xmc/workflows/4-implementation/sprint-planning/workflow.md,xiaoma-xmc-sprint-planning,true,sm,Create Mode,"Generate sprint plan for development tasks - this kicks off the implementation phase by producing a plan the implementation agents will follow in sequence for every story in the plan.",implementation_artifacts,"sprint status",
+xmc,4-implementation,Sprint Status,SS,20,_xiaoma/xmc/workflows/4-implementation/sprint-status/workflow.md,xiaoma-xmc-sprint-status,false,sm,Create Mode,"Anytime: Summarize sprint status and route to next workflow",,,
+xmc,4-implementation,Validate Story,VS,35,_xiaoma/xmc/workflows/4-implementation/create-story/workflow.md,xiaoma-xmc-create-story,false,sm,Validate Mode,"Validates story readiness and completeness before development work begins",implementation_artifacts,"story validation report",
+xmc,4-implementation,Create Story,CS,30,_xiaoma/xmc/workflows/4-implementation/create-story/workflow.md,xiaoma-xmc-create-story,true,sm,Create Mode,"Story cycle start: Prepare first found story in the sprint plan that is next, or if the command is run with a specific epic and story designation with context. Once complete, then VS then DS then CR then back to DS if needed or next CS or ER",implementation_artifacts,story,
+xmc,4-implementation,Dev Story,DS,40,_xiaoma/xmc/workflows/4-implementation/dev-story/workflow.md,xiaoma-xmc-dev-story,true,dev,Create Mode,"Story cycle: Execute story implementation tasks and tests then CR then back to DS if fixes needed",,,
+xmc,4-implementation,Code Review,CR,50,_xiaoma/xmc/workflows/4-implementation/code-review/workflow.md,xiaoma-xmc-code-review,false,dev,Create Mode,"Story cycle: If issues back to DS if approved then next CS or ER if epic complete",,,
+xmc,4-implementation,QA Automation Test,QA,45,_xiaoma/xmc/workflows/qa-generate-e2e-tests/workflow.md,xiaoma-xmc-qa-automate,false,qa,Create Mode,"Generate automated API and E2E tests for implemented code using the project's existing test framework (detects existing well known in use test frameworks). Use after implementation to add test coverage. NOT for code review or story validation - use CR for that.",implementation_artifacts,"test suite",
+xmc,4-implementation,Retrospective,ER,60,_xiaoma/xmc/workflows/4-implementation/retrospective/workflow.md,xiaoma-xmc-retrospective,false,sm,Create Mode,"Optional at epic end: Review completed work lessons learned and next epic or if major issues consider CC",implementation_artifacts,retrospective,

package/src/xmc/module.yaml

@@ -0,0 +1,50 @@
+code: xmc
+name: "XiaoMa Method Agile-AI Driven-Development"
+description: "AI-driven agile development framework"
+default_selected: true # This module will be selected by default for new installations
+
+# Variables from Core Config inserted:
+## user_name
+## communication_language
+## document_output_language
+## output_folder
+
+project_name:
+  prompt: "What is your project called?"
+  default: "{directory_name}"
+  result: "{value}"
+
+user_skill_level:
+  prompt:
+    - "What is your development experience level?"
+    - "This affects how agents explain concepts in chat."
+  default: "intermediate"
+  result: "{value}"
+  single-select:
+    - value: "beginner"
+      label: "Beginner - Explain things clearly"
+    - value: "intermediate"
+      label: "Intermediate - Balance detail with speed"
+    - value: "expert"
+      label: "Expert - Be direct and technical"
+
+planning_artifacts: # Phase 1-3 artifacts
+  prompt: "Where should planning artifacts be stored? (Brainstorming, Briefs, PRDs, UX Designs, Architecture, Epics)"
+  default: "{output_folder}/planning-artifacts"
+  result: "{project-root}/{value}"
+
+implementation_artifacts: # Phase 4 artifacts and quick-dev flow output
+  prompt: "Where should implementation artifacts be stored? (Sprint status, stories, reviews, retrospectives, Quick Flow output)"
+  default: "{output_folder}/implementation-artifacts"
+  result: "{project-root}/{value}"
+
+project_knowledge: # Artifacts from research, document-project output, other long lived accurate knowledge
+  prompt: "Where should long-term project knowledge be stored? (docs, research, references)"
+  default: "docs"
+  result: "{project-root}/{value}"
+
+# Directories to create during installation (declarative, no code execution)
+directories:
+  - "{planning_artifacts}"
+  - "{implementation_artifacts}"
+  - "{project_knowledge}"

package/src/xmc/sub-modules/claude-code/config.yaml

@@ -0,0 +1,5 @@
+# Powered by XIAOMA™ Core
+name: xmccc
+short-title: XMC Claude Code Sub Module
+author: Brian (XiaoMa) Madison
+submodule: true

package/src/xmc/sub-modules/claude-code/injections.yaml

@@ -0,0 +1,242 @@
+# Claude Code Content Injection Configuration
+# This file defines content to be injected at specific points in XIAOMA files
+# when Claude Code is selected as the IDE during installation
+#
+# The installer will:
+# 1. Ask users if they want to install subagents (all/selective/none)
+# 2. Ask where to install (project-level .claude/agents/{xiaoma_folder}/ or user-level ~/.claude/agents/{xiaoma_folder}/)
+# 3. Only inject content related to selected subagents
+# 4. Templates stay in {xiaoma_folder}/ directory and are referenced from there
+# 5. Injections are placed at specific sections where each subagent is most valuable
+
+injections:
+  # ===== PRD WORKFLOW INJECTIONS =====
+
+  # PRD Subagent Instructions
+  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
+    point: "prd-subagent-instructions"
+    requires: "all-prd-subagents"
+    content: |
+
+      **Subagent Usage**: Throughout this workflow, leverage specialized subagents at critical decision points:
+      - <CRITICAL>Use `xmc-requirements-analyst` when defining functional requirements</CRITICAL>
+      - <CRITICAL>Use `xmc-user-journey-mapper` for comprehensive journey mapping</CRITICAL>
+      - <CRITICAL>Use `xmc-epic-optimizer` when structuring epic boundaries</CRITICAL>
+      - <CRITICAL>Use `xmc-technical-decisions-curator` to capture all technical mentions</CRITICAL>
+
+  # PRD Requirements Analysis
+  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
+    point: "prd-requirements-analysis"
+    requires: "requirements-analyst"
+    content: |
+
+      **Subagent Hint**: Use `xmc-requirements-analyst` to validate requirements are testable and complete.
+
+  # PRD User Journey Mapping
+  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
+    point: "prd-user-journey"
+    requires: "user-journey-mapper"
+    content: |
+
+      **Subagent Hint**: Use `xmc-user-journey-mapper` to map all user types and their value paths.
+
+  # PRD Epic Optimization
+  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
+    point: "prd-epic-optimization"
+    requires: "epic-optimizer"
+    content: |
+
+      **Subagent Hint**: Use `xmc-epic-optimizer` to validate epic boundaries deliver coherent value.
+
+  # PRD Document Review
+  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
+    point: "prd-checklist-review"
+    requires: "document-reviewer"
+    content: |
+
+      **Subagent Hint**: Use `xmc-document-reviewer` to validate PRD completeness before finalizing.
+
+  # Technical Decisions Curator
+  - file: "{xiaoma_folder}/xmc/workflows/prd/instructions.md"
+    point: "technical-decisions-curator"
+    requires: "technical-decisions-curator"
+    content: |
+
+      **Automatic Capture**: The `xmc-technical-decisions-curator` should be invoked whenever:
+      - Technology, framework, or tool is mentioned
+      - Architecture patterns are discussed
+      - Infrastructure or deployment topics arise
+      - Integration requirements are specified
+
+  # ===== MARKET RESEARCH TEMPLATE INJECTIONS =====
+
+  # Market TAM/SAM/SOM Calculations
+  - file: "{xiaoma_folder}/xmc/templates/market.md"
+    point: "market-tam-calculations"
+    requires: "data-analyst"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-data-analyst' subagent to perform all TAM, SAM, and SOM calculations.</i>
+        <i>The subagent will apply proper methodologies, validate assumptions, and provide defensible market sizing.</i>
+      </llm>
+
+  # Market Trends Analysis
+  - file: "{xiaoma_folder}/xmc/templates/market.md"
+    point: "market-trends-analysis"
+    requires: "trend-spotter"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-trend-spotter' subagent to identify and analyze emerging market trends.</i>
+        <i>The subagent will detect disruption signals, technology shifts, and future opportunities.</i>
+      </llm>
+
+  # Market Customer Personas
+  - file: "{xiaoma_folder}/xmc/templates/market.md"
+    point: "market-customer-segments"
+    requires: "user-researcher"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-user-researcher' subagent to develop detailed customer segment profiles and personas.</i>
+        <i>The subagent will analyze behavior patterns, needs, and journey maps for each segment.</i>
+      </llm>
+
+  # Market Research Review
+  - file: "{xiaoma_folder}/xmc/templates/market.md"
+    point: "market-executive-summary"
+    requires: "document-reviewer"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Before finalizing the executive summary, use the 'xmc-document-reviewer' subagent to validate all market research findings and ensure data accuracy.</i>
+      </llm>
+
+  # ===== COMPETITOR ANALYSIS TEMPLATE INJECTIONS =====
+
+  # Competitor Intelligence Gathering
+  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
+    point: "competitor-intelligence"
+    requires: "market-researcher"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-market-researcher' subagent to gather comprehensive competitive intelligence for each competitor profile.</i>
+        <i>The subagent will analyze positioning, strategy, and market dynamics.</i>
+      </llm>
+
+  # Competitor Technical Analysis
+  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
+    point: "competitor-tech-stack"
+    requires: "technical-evaluator"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-technical-evaluator' subagent to analyze and compare competitor technology stacks.</i>
+        <i>The subagent will identify technical differentiators and architectural advantages.</i>
+      </llm>
+
+  # Competitor Metrics Analysis
+  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
+    point: "competitor-metrics"
+    requires: "data-analyst"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-data-analyst' subagent to analyze competitor performance metrics and market share data.</i>
+      </llm>
+
+  # Competitor Analysis Review
+  - file: "{xiaoma_folder}/xmc/templates/competitor.md"
+    point: "competitor-executive-summary"
+    requires: "document-reviewer"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Before finalizing, use the 'xmc-document-reviewer' subagent to validate competitive analysis completeness and strategic recommendations.</i>
+      </llm>
+
+  # ===== PROJECT BRIEF TEMPLATE INJECTIONS =====
+
+  # Brief Problem Validation
+  - file: "{xiaoma_folder}/xmc/templates/brief.md"
+    point: "brief-problem-validation"
+    requires: "market-researcher"
+    content: |
+
+      <llm critical="true">
+        <i>IF market research has not been provided as input, MANDATORY: Use the 'xmc-market-researcher' subagent to validate the problem statement and assess market opportunity.</i>
+      </llm>
+
+  # Brief Target User Analysis
+  - file: "{xiaoma_folder}/xmc/templates/brief.md"
+    point: "brief-user-analysis"
+    requires: "user-researcher"
+    content: |
+
+      <llm critical="true">
+        <i>IF target user analysis has not been provided, MANDATORY: Use the 'xmc-user-researcher' subagent to develop detailed user profiles and validate user needs.</i>
+      </llm>
+
+  # Brief Success Metrics
+  - file: "{xiaoma_folder}/xmc/templates/brief.md"
+    point: "brief-success-metrics"
+    requires: "data-analyst"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-data-analyst' subagent to define and validate KPIs, success metrics, and measurement approaches.</i>
+      </llm>
+
+  # Brief Technical Feasibility
+  - file: "{xiaoma_folder}/xmc/templates/brief.md"
+    point: "brief-technical-feasibility"
+    requires: "technical-evaluator"
+    content: |
+
+      <llm critical="true">
+        <i>IF technical assumptions need validation, use the 'xmc-technical-evaluator' subagent to assess feasibility and identify technical risks.</i>
+      </llm>
+
+  # Brief Requirements Extraction
+  - file: "{xiaoma_folder}/xmc/templates/brief.md"
+    point: "brief-requirements"
+    requires: "requirements-analyst"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Use the 'xmc-requirements-analyst' subagent to extract initial high-level requirements from the brief content.</i>
+      </llm>
+
+  # Brief Document Review
+  - file: "{xiaoma_folder}/xmc/templates/brief.md"
+    point: "brief-final-review"
+    requires: "document-reviewer"
+    content: |
+
+      <llm critical="true">
+        <i>MANDATORY: Before finalizing the brief, use the 'xmc-document-reviewer' subagent to ensure completeness and internal consistency.</i>
+      </llm>
+
+# Subagents to copy
+subagents:
+  source: "sub-agents"
+  target: ".claude/agents"
+  files:
+    - "market-researcher.md"
+    - "requirements-analyst.md"
+    - "technical-evaluator.md"
+    - "epic-optimizer.md"
+    - "document-reviewer.md"
+    - "codebase-analyzer.md"
+    - "dependency-mapper.md"
+    - "pattern-detector.md"
+    - "tech-debt-auditor.md"
+    - "api-documenter.md"
+    - "test-coverage-analyzer.md"
+    - "user-researcher.md"
+    - "user-journey-mapper.md"
+    - "technical-decisions-curator.md"
+    - "data-analyst.md"
+    - "trend-spotter.md"

package/src/xmc/sub-modules/claude-code/readme.md

@@ -0,0 +1,87 @@
+# XMC Claude Code Sub-Module
+
+## Overview
+
+This sub-module provides Claude Code-specific enhancements for the XMC module, including specialized subagents and content injection for enhanced AI-assisted development workflows.
+
+## How the Installer Works
+
+When Claude Code is selected during XIAOMA installation:
+
+1. **Module Detection**: The installer checks for `sub-modules/claude-code/` in each selected module
+2. **Configuration Loading**: Reads `injections.yaml` to understand what to inject and which subagents are available
+3. **User Interaction**: Prompts users to:
+   - Choose subagent installation (all/selective/none)
+   - Select installation location (project `.claude/agents/` or user `~/.claude/agents/`)
+4. **Selective Installation**: Based on user choices:
+   - Copies only selected subagents to Claude's agents directory
+   - Injects only relevant content at defined injection points
+   - Skips injection if no subagents selected
+
+## Subagent Directory
+
+### Product Management Subagents
+
+| Subagent                 | Purpose                                  | Used By    | Recommended For                               |
+| ------------------------ | ---------------------------------------- | ---------- | --------------------------------------------- |
+| **market-researcher**    | Competitive analysis and market insights | PM Agent   | PRD creation (`*create-prd`), market analysis |
+| **requirements-analyst** | Extract and validate requirements        | PM Agent   | Requirements sections, user story creation    |
+| **technical-evaluator**  | Technology stack evaluation              | PM Agent   | Technical assumptions in PRDs                 |
+| **epic-optimizer**       | Story breakdown and sizing               | PM Agent   | Epic details, story sequencing                |
+| **document-reviewer**    | Quality checks and validation            | PM/Analyst | Final document review before delivery         |
+
+### Architecture and Documentation Subagents
+
+| Subagent                   | Purpose                                   | Used By   | Recommended For                                |
+| -------------------------- | ----------------------------------------- | --------- | ---------------------------------------------- |
+| **codebase-analyzer**      | Project structure and tech stack analysis | Architect | `*generate-context-docs` (doc-proj task)       |
+| **dependency-mapper**      | Module and package dependency analysis    | Architect | Brownfield documentation, refactoring planning |
+| **pattern-detector**       | Identify patterns and conventions         | Architect | Understanding existing codebases               |
+| **tech-debt-auditor**      | Assess technical debt and risks           | Architect | Brownfield architecture, migration planning    |
+| **api-documenter**         | Document APIs and integrations            | Architect | API documentation, service boundaries          |
+| **test-coverage-analyzer** | Analyze test suites and coverage          | Architect | Test strategy, quality assessment              |
+
+## Adding New Subagents
+
+1. **Create the subagent file** in `sub-agents/`:
+
+   ```markdown
+   ---
+   name: your-subagent-name
+   description: Brief description. use PROACTIVELY when [specific scenario]
+   tools: Read, Write, Grep # Specify required tools - check claude-code docs to see what tools are available, or just leave blank to allow all
+   ---
+
+   [System prompt describing the subagent's role and expertise]
+   ```
+
+2. **Add to injections.yaml**:
+   - Add filename to `subagents.files` list
+   - Update relevant agent injection content if needed
+
+3. **Create injection point** (if new agent):
+   ```xml
+   <!-- IDE-INJECT-POINT: agent-name-instructions -->
+   ```
+
+## Injection Points
+
+All injection points in this module are documented in: `{project-root}{output_folder}/injection-points.md` - ensure this is kept up to date.
+
+Injection points allow IDE-specific content to be added during installation without modifying source files. They use HTML comment syntax and are replaced during the installation process based on user selections.
+
+## Configuration Files
+
+- **injections.yaml**: Defines what content to inject and where
+- **config.yaml**: Additional Claude Code configuration (if needed)
+- **sub-agents/**: Directory containing all subagent definitions
+
+## Testing
+
+To test subagent installation:
+
+1. Run the XIAOMA installer
+2. Select XMC module and Claude Code
+3. Verify prompts appear for subagent selection
+4. Check `.claude/agents/` for installed subagents
+5. Verify injection points are replaced in `.claude/commands/{xiaoma_folder}/` and the various tasks and templates under `{xiaoma_folder}/...`

package/src/xmc/sub-modules/claude-code/sub-agents/xiaoma-analysis/api-documenter.md

@@ -0,0 +1,102 @@
+---
+name: xmc-api-documenter
+description: Documents APIs, interfaces, and integration points including REST endpoints, GraphQL schemas, message contracts, and service boundaries. use PROACTIVELY when documenting system interfaces or planning integrations
+tools:
+---
+
+You are an API Documentation Specialist focused on discovering and documenting all interfaces through which systems communicate. Your expertise covers REST APIs, GraphQL schemas, gRPC services, message queues, webhooks, and internal module interfaces.
+
+## Core Expertise
+
+You specialize in endpoint discovery and documentation, request/response schema extraction, authentication and authorization flow documentation, error handling patterns, rate limiting and throttling rules, versioning strategies, and integration contract definition. You understand various API paradigms and documentation standards.
+
+## Discovery Techniques
+
+**REST API Analysis**
+
+- Locate route definitions in frameworks (Express, FastAPI, Spring, etc.)
+- Extract HTTP methods, paths, and parameters
+- Identify middleware and filters
+- Document request/response bodies
+- Find validation rules and constraints
+- Detect authentication requirements
+
+**GraphQL Schema Analysis**
+
+- Parse schema definitions
+- Document queries, mutations, subscriptions
+- Extract type definitions and relationships
+- Identify resolvers and data sources
+- Document directives and permissions
+
+**Service Interface Analysis**
+
+- Identify service boundaries
+- Document RPC methods and parameters
+- Extract protocol buffer definitions
+- Find message queue topics and schemas
+- Document event contracts
+
+## Documentation Methodology
+
+Extract API definitions from code, not just documentation. Compare documented behavior with actual implementation. Identify undocumented endpoints and features. Find deprecated endpoints still in use. Document side effects and business logic. Include performance characteristics and limitations.
+
+## Output Format
+
+Provide comprehensive API documentation:
+
+- **API Inventory**: All endpoints/methods with purpose
+- **Authentication**: How to authenticate, token types, scopes
+- **Endpoints**: Detailed documentation for each endpoint
+  - Method and path
+  - Parameters (path, query, body)
+  - Request/response schemas with examples
+  - Error responses and codes
+  - Rate limits and quotas
+- **Data Models**: Shared schemas and types
+- **Integration Patterns**: How services communicate
+- **Webhooks/Events**: Async communication contracts
+- **Versioning**: API versions and migration paths
+- **Testing**: Example requests, postman collections
+
+## Schema Documentation
+
+For each data model:
+
+- Field names, types, and constraints
+- Required vs optional fields
+- Default values and examples
+- Validation rules
+- Relationships to other models
+- Business meaning and usage
+
+## Critical Behaviors
+
+Document the API as it actually works, not as it's supposed to work. Include undocumented but functioning endpoints that clients might depend on. Note inconsistencies in error handling or response formats. Identify missing CORS headers, authentication bypasses, or security issues. Document rate limits, timeouts, and size restrictions that might not be obvious.
+
+For brownfield systems:
+
+- Legacy endpoints maintained for backward compatibility
+- Inconsistent patterns between old and new APIs
+- Undocumented internal APIs used by frontends
+- Hardcoded integrations with external services
+- APIs with multiple authentication methods
+- Versioning strategies (or lack thereof)
+- Shadow APIs created for specific clients
+
+## CRITICAL: Final Report Instructions
+
+**YOU MUST RETURN YOUR COMPLETE API DOCUMENTATION IN YOUR FINAL MESSAGE.**
+
+Your final report MUST include all API documentation you've discovered and analyzed in full detail. Do not just describe what you found - provide the complete, formatted API documentation ready for integration.
+
+Include in your final report:
+
+1. Complete API inventory with all endpoints/methods
+2. Full authentication and authorization documentation
+3. Detailed endpoint specifications with schemas
+4. Data models and type definitions
+5. Integration patterns and examples
+6. Any security concerns or inconsistencies found
+
+Remember: Your output will be used directly by the parent agent to populate documentation sections. Provide complete, ready-to-use content, not summaries or references.

package/src/xmc/sub-modules/claude-code/sub-agents/xiaoma-analysis/codebase-analyzer.md

@@ -0,0 +1,82 @@
+---
+name: xmc-codebase-analyzer
+description: Performs comprehensive codebase analysis to understand project structure, architecture patterns, and technology stack. use PROACTIVELY when documenting projects or analyzing brownfield codebases
+tools:
+---
+
+You are a Codebase Analysis Specialist focused on understanding and documenting complex software projects. Your role is to systematically explore codebases to extract meaningful insights about architecture, patterns, and implementation details.
+
+## Core Expertise
+
+You excel at project structure discovery, technology stack identification, architectural pattern recognition, module dependency analysis, entry point identification, configuration analysis, and build system understanding. You have deep knowledge of various programming languages, frameworks, and architectural patterns.
+
+## Analysis Methodology
+
+Start with high-level structure discovery using file patterns and directory organization. Identify the technology stack from configuration files, package managers, and build scripts. Locate entry points, main modules, and critical paths through the application. Map module boundaries and their interactions. Document actual patterns used, not theoretical best practices. Identify deviations from standard patterns and understand why they exist.
+
+## Discovery Techniques
+
+**Project Structure Analysis**
+
+- Use glob patterns to map directory structure: `**/*.{js,ts,py,java,go}`
+- Identify source, test, configuration, and documentation directories
+- Locate build artifacts, dependencies, and generated files
+- Map namespace and package organization
+
+**Technology Stack Detection**
+
+- Check package.json, requirements.txt, go.mod, pom.xml, Gemfile, etc.
+- Identify frameworks from imports and configuration files
+- Detect database technologies from connection strings and migrations
+- Recognize deployment platforms from config files (Dockerfile, kubernetes.yaml)
+
+**Pattern Recognition**
+
+- Identify architectural patterns: MVC, microservices, event-driven, layered
+- Detect design patterns: factory, repository, observer, dependency injection
+- Find naming conventions and code organization standards
+- Recognize testing patterns and strategies
+
+## Output Format
+
+Provide structured analysis with:
+
+- **Project Overview**: Purpose, domain, primary technologies
+- **Directory Structure**: Annotated tree with purpose of each major directory
+- **Technology Stack**: Languages, frameworks, databases, tools with versions
+- **Architecture Patterns**: Identified patterns with examples and locations
+- **Key Components**: Entry points, core modules, critical services
+- **Dependencies**: External libraries, internal module relationships
+- **Configuration**: Environment setup, deployment configurations
+- **Build and Deploy**: Build process, test execution, deployment pipeline
+
+## Critical Behaviors
+
+Always verify findings with actual code examination, not assumptions. Document what IS, not what SHOULD BE according to best practices. Note inconsistencies and technical debt honestly. Identify workarounds and their reasons. Focus on information that helps other agents understand and modify the codebase. Provide specific file paths and examples for all findings.
+
+When analyzing brownfield projects, pay special attention to:
+
+- Legacy code patterns and their constraints
+- Technical debt accumulation points
+- Integration points with external systems
+- Areas of high complexity or coupling
+- Undocumented tribal knowledge encoded in the code
+- Workarounds and their business justifications
+
+## CRITICAL: Final Report Instructions
+
+**YOU MUST RETURN YOUR COMPLETE CODEBASE ANALYSIS IN YOUR FINAL MESSAGE.**
+
+Your final report MUST include the full codebase analysis you've performed in complete detail. Do not just describe what you analyzed - provide the complete, formatted analysis documentation ready for use.
+
+Include in your final report:
+
+1. Complete project structure with annotated directory tree
+2. Full technology stack identification with versions
+3. All identified architecture and design patterns with examples
+4. Key components and entry points with file paths
+5. Dependency analysis and module relationships
+6. Configuration and deployment details
+7. Technical debt and complexity areas identified
+
+Remember: Your output will be used directly by the parent agent to understand and document the codebase. Provide complete, ready-to-use content, not summaries or references.