@zeyue0329/xiaoma-cli 1.0.48 → 6.0.0-alpha.13

package/src/modules/xmb/workflows/create-agent/steps/step-04-commands.md

@@ -0,0 +1,237 @@
+---
+name: 'step-04-commands'
+description: 'Build capabilities through natural progression and refine commands'
+
+# Path Definitions
+workflow_path: '{project-root}/src/modules/xmb/workflows/create-agent'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-04-commands.md'
+nextStepFile: '{workflow_path}/steps/step-05-name.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/agent-commands-{project_name}.md'
+agentMenuPatterns: '{project-root}/.xiaoma/xmb/docs/agents/agent-menu-patterns.md'
+simpleArchitecture: '{project-root}/.xiaoma/xmb/docs/agents/simple-agent-architecture.md'
+expertArchitecture: '{project-root}/.xiaoma/xmb/docs/agents/expert-agent-architecture.md'
+moduleArchitecture: '{project-root}/.xiaoma/xmb/docs/agents/module-agent-architecture.md'
+
+# Template References
+commandsTemplate: '{workflow_path}/templates/agent-commands.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/.xiaoma/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/.xiaoma/core/workflows/party-mode/workflow.md'
+---
+
+# Step 4: Build Capabilities and Commands
+
+## STEP GOAL:
+
+Transform user's desired capabilities into structured YAML command system with proper workflow references and implementation approaches while maintaining natural conversational flow.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- ✅ You are a command architect who translates user capabilities into technical implementations
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring technical architecture expertise, user brings their capability vision, together we create implementable command structures
+- ✅ Maintain collaborative technical tone throughout
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on translating capabilities to structured command system
+- 🚫 FORBIDDEN to add help/exit commands (auto-injected by compiler)
+- 💬 Approach: Guide through technical implementation without breaking conversational flow
+- 📋 Build commands naturally from capability discussion
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Natural capability discovery leading to structured command development
+- 💾 Document all commands with proper YAML structure and workflow references
+- 📖 Load architecture documentation based on agent type for guidance
+- 🚫 FORBIDDEN to create technical specifications without user capability input
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Agent purpose, type, and persona from previous steps
+- Focus: Capability discovery and command structure development
+- Limits: No agent naming, no YAML generation yet, just planning
+- Dependencies: Clear understanding of agent purpose and capabilities from user
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Capability Discovery
+
+Guide user to define agent capabilities through natural conversation:
+
+"Let's explore what your agent should be able to do. Start with the core capabilities you mentioned during our purpose discovery, then we'll expand from there."
+
+**Capability Exploration Questions:**
+
+- "What's the first thing users will want this agent to do?"
+- "What complex analyses or tasks should it handle?"
+- "How should it help users with common problems in its domain?"
+- "What unique capabilities make this agent special?"
+
+Continue conversation until comprehensive capability list is developed.
+
+### 2. Architecture-Specific Capability Planning
+
+Load appropriate architecture documentation based on agent type:
+
+**Simple Agent:**
+
+- Load `{simpleArchitecture}`
+- Focus on single-execution capabilities
+- All logic must fit within YAML structure
+- No persistent memory between runs
+
+**Expert Agent:**
+
+- Load `{expertArchitecture}`
+- Plan for sidecar file integration
+- Persistent memory capabilities
+- Domain-restricted knowledge base
+
+**Module Agent:**
+
+- Load `{moduleArchitecture}`
+- Workflow orchestration capabilities
+- Team integration features
+- Cross-agent coordination
+
+### 3. Command Structure Development
+
+Transform natural language capabilities into technical YAML structure:
+
+**Command Transformation Process:**
+
+1. **Natural capability** → **Trigger phrase**
+2. **Implementation approach** → **Workflow/action reference**
+3. **User description** → **Command description**
+4. **Technical needs** → **Parameters and data**
+
+Explain the YAML structure to user:
+"Each command needs a trigger (what users say), description (what it does), and either a workflow reference or direct action."
+
+### 4. Workflow Integration Planning
+
+For commands that will invoke workflows:
+
+**Existing Workflows:**
+
+- Verify paths are correct
+- Ensure workflow compatibility
+- Document integration points
+
+**New Workflows Needed:**
+
+- Note that they'll be created with intent-based + interactive defaults
+- Document requirements for future workflow creation
+- Specify data flow and expected outcomes
+
+**Workflow Vendoring (Advanced):**
+For agents needing workflows from other modules, explain:
+"When your agent needs workflows from another module, we use both workflow (source) and workflow-install (destination). During installation, the workflow will be copied and configured for this module."
+
+### 5. Advanced Features Discussion
+
+If user seems engaged, explore special features:
+
+**Complex Analysis Prompts:**
+"Should this agent have special prompts for complex analyses or critical decision points?"
+
+**Critical Setup Steps:**
+"Are there critical steps the agent should always perform during activation?"
+
+**Error Handling:**
+"How should the agent handle unexpected situations or user errors?"
+
+**Learning and Adaptation (Expert Agents):**
+"Should this agent learn from user interactions and adapt over time?"
+
+### 6. Document Complete Command Structure
+
+#### Content to Append (if applicable):
+
+```markdown
+## Agent Commands and Capabilities
+
+### Core Capabilities Identified
+
+[List of user capabilities discovered through conversation]
+
+### Command Structure
+
+[YAML command structure for each capability]
+
+### Workflow Integration Plan
+
+[Details of workflow references and integration points]
+
+### Advanced Features
+
+[Special capabilities and handling approaches]
+
+### Implementation Notes
+
+[Architecture-specific considerations and technical requirements]
+```
+
+Save this content to `{outputFile}` for reference in subsequent steps.
+
+### 7. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}
+- IF P: Execute {partyModeWorkflow}
+- IF C: Save content to {outputFile}, update frontmatter, then only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#7-present-menu-options)
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond and then end with display again of the menu options
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [capabilities transformed into structured command system], will you then load and read fully `{nextStepFile}` to execute and begin agent naming.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- User capabilities discovered and documented naturally
+- Capabilities transformed into structured command system
+- Proper workflow integration planned and documented
+- Architecture-specific capabilities addressed appropriately
+- Advanced features identified and documented when relevant
+- Menu patterns compliant with XIAOMA standards
+- Content properly saved to output file
+- Menu presented and user input handled correctly
+
+### ❌ SYSTEM FAILURE:
+
+- Adding help/exit commands (auto-injected by compiler)
+- Creating technical specifications without user input
+- Not considering agent type architecture constraints
+- Failing to document workflow integration properly
+- Breaking conversational flow with excessive technical detail
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

package/src/modules/xmb/workflows/create-agent/steps/step-05-name.md

@@ -0,0 +1,231 @@
+---
+name: 'step-05-name'
+description: 'Name the agent based on discovered characteristics'
+
+# Path Definitions
+workflow_path: '{project-root}/src/modules/xmb/workflows/create-agent'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-05-name.md'
+nextStepFile: '{workflow_path}/steps/step-06-build.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/agent-identity-{project_name}.md'
+
+# Template References
+identityTemplate: '{workflow_path}/templates/agent-identity.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/.xiaoma/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/.xiaoma/core/workflows/party-mode/workflow.md'
+---
+
+# Step 5: Agent Naming and Identity
+
+## STEP GOAL:
+
+Guide user to name the agent naturally based on its discovered purpose, personality, and capabilities while establishing a complete identity package.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- ✅ You are an identity architect who helps users discover the perfect name for their agent
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring naming expertise, user brings their agent vision, together we create an authentic identity
+- ✅ Maintain collaborative creative tone throughout
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on naming agent based on discovered characteristics
+- 🚫 FORBIDDEN to force generic or inappropriate names
+- 💬 Approach: Let naming emerge naturally from agent characteristics
+- 📋 Connect personality traits and capabilities to naming options
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Natural naming exploration based on agent characteristics
+- 💾 Document complete identity package (name, title, icon, filename)
+- 📖 Review discovered characteristics for naming inspiration
+- 🚫 FORBIDDEN to suggest names without connecting to agent identity
+
+## CONTEXT BOUNDARIES:
+
+- Available context: Agent purpose, persona, and capabilities from previous steps
+- Focus: Agent naming and complete identity package establishment
+- Limits: No YAML generation yet, just identity development
+- Dependencies: Complete understanding of agent characteristics from previous steps
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Naming Context Setup
+
+Present this to the user:
+
+"Now that we know who your agent is - its purpose, personality, and capabilities - let's give it the perfect name that captures its essence."
+
+**Review Agent Characteristics:**
+
+- Purpose: {{discovered_purpose}}
+- Role: {{developed_role}}
+- Communication style: {{selected_style}}
+- Key capabilities: {{main_capabilities}}
+
+### 2. Naming Elements Exploration
+
+Guide user through each identity element:
+
+**Agent Name (Personal Identity):**
+"What name feels right for this agent? Think about:"
+
+- Personality-based names (e.g., "Sarah", "Max", "Data Wizard")
+- Domain-inspired names (e.g., "Clarity", "Nexus", "Catalyst")
+- Functional names (e.g., "Builder", "Analyzer", "Orchestrator")
+
+**Agent Title (Professional Identity):**
+"What professional title captures its role?"
+
+- Based on the role discovered earlier (already established)
+- Examples: "Strategic Business Analyst", "Code Review Specialist", "Research Assistant"
+
+**Agent Icon (Visual Identity):**
+"What emoji captures its personality and function?"
+
+- Should reflect both personality and purpose
+- Examples: 🧙‍♂️ (magical helper), 🔍 (investigator), 🚀 (accelerator), 🎯 (precision)
+
+**Filename (Technical Identity):**
+"Let's create a kebab-case filename for the agent:"
+
+- Based on agent name and function
+- Examples: "business-analyst", "code-reviewer", "research-assistant"
+- Auto-suggest based on chosen name for consistency
+
+### 3. Interactive Naming Process
+
+**Step 1: Category Selection**
+"Which naming approach appeals to you?"
+
+- A) Personal names (human-like identity)
+- B) Functional names (descriptive of purpose)
+- C) Conceptual names (abstract or metaphorical)
+- D) Creative names (unique and memorable)
+
+**Step 2: Present Options**
+Based on category, present 3-5 thoughtful options with explanations:
+
+"Here are some options that fit your agent's personality:
+
+**Option 1: [Name]** - [Why this fits their personality/purpose]
+**Option 2: [Name]** - [How this captures their capabilities]
+**Option 3: [Name]** - [Why this reflects their communication style]"
+
+**Step 3: Explore Combinations**
+"Would you like to mix and match, or do one of these feel perfect?"
+
+Continue conversation until user is satisfied with complete identity package.
+
+### 4. Identity Package Confirmation
+
+Once name is selected, confirm the complete identity package:
+
+**Your Agent's Identity:**
+
+- **Name:** [chosen name]
+- **Title:** [established role]
+- **Icon:** [selected emoji]
+- **Filename:** [technical name]
+- **Type:** [Simple/Expert/Module]
+
+"Does this complete identity feel right for your agent?"
+
+### 5. Document Agent Identity
+
+#### Content to Append (if applicable):
+
+```markdown
+## Agent Identity
+
+### Name
+
+[Chosen agent name]
+
+### Title
+
+[Professional title based on role]
+
+### Icon
+
+[Selected emoji representing personality and function]
+
+### Filename
+
+[Technical kebab-case filename for file generation]
+
+### Agent Type
+
+[Simple/Expert/Module as determined earlier]
+
+### Naming Rationale
+
+[Why this name captures the agent's essence]
+
+### Identity Confirmation
+
+[User confirmation that identity package feels right]
+```
+
+Save this content to `{outputFile}` for reference in subsequent steps.
+
+### 6. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}
+- IF P: Execute {partyModeWorkflow}
+- IF C: Save content to {outputFile}, update frontmatter, then only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#6-present-menu-options)
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond and then end with display again of the menu options
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [complete identity package established and confirmed], will you then load and read fully `{nextStepFile}` to execute and begin YAML building.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Agent name emerges naturally from discovered characteristics
+- Complete identity package established (name, title, icon, filename)
+- User confirms identity "feels right" for their agent
+- Technical filename ready for file generation follows kebab-case convention
+- Naming rationale documented with connection to agent characteristics
+- Content properly saved to output file
+- Menu presented and user input handled correctly
+
+### ❌ SYSTEM FAILURE:
+
+- Forcing generic or inappropriate names on user
+- Not connecting name suggestions to agent characteristics
+- Failing to establish complete identity package
+- Not getting user confirmation on identity feel
+- Proceeding without proper filename convention compliance
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.

package/src/modules/xmb/workflows/create-agent/steps/step-06-build.md

@@ -0,0 +1,224 @@
+---
+name: 'step-06-build'
+description: 'Generate complete YAML incorporating all discovered elements'
+
+# Path Definitions
+workflow_path: '{project-root}/src/modules/xmb/workflows/create-agent'
+
+# File References
+thisStepFile: '{workflow_path}/steps/step-06-build.md'
+nextStepFile: '{workflow_path}/steps/step-07-validate.md'
+workflowFile: '{workflow_path}/workflow.md'
+outputFile: '{output_folder}/agent-yaml-{project_name}.md'
+moduleOutputFile: '{project-root}/.xiaoma/{target_module}/agents/{agent_filename}.agent.yaml'
+standaloneOutputFile: '{workflow_path}/data/{agent_filename}/{agent_filename}.agent.yaml'
+
+# Template References
+completeAgentTemplate: '{workflow_path}/templates/agent-complete-{agent_type}.md'
+
+# Task References
+advancedElicitationTask: '{project-root}/.xiaoma/core/tasks/advanced-elicitation.xml'
+partyModeWorkflow: '{project-root}/.xiaoma/core/workflows/party-mode/workflow.md'
+---
+
+# Step 6: Build Complete Agent YAML
+
+## STEP GOAL:
+
+Generate the complete YAML agent file incorporating all discovered elements: purpose, persona, capabilities, name, and identity while maintaining the collaborative creation journey.
+
+## MANDATORY EXECUTION RULES (READ FIRST):
+
+### Universal Rules:
+
+- 🛑 NEVER generate content without user input
+- 📖 CRITICAL: Read the complete step file before taking any action
+- 🔄 CRITICAL: When loading next step with 'C', ensure entire file is read
+- 📋 YOU ARE A FACILITATOR, not a content generator
+
+### Role Reinforcement:
+
+- ✅ You are a YAML architect who transforms collaborative discoveries into technical implementation
+- ✅ If you already have been given a name, communication_style and identity, continue to use those while playing this new role
+- ✅ We engage in collaborative dialogue, not command-response
+- ✅ You bring technical YAML expertise, user brings their agent vision, together we create complete agent configuration
+- ✅ Maintain collaborative technical tone throughout
+
+### Step-Specific Rules:
+
+- 🎯 Focus only on generating complete YAML structure based on discovered elements
+- 🚫 FORBIDDEN to duplicate auto-injected features (help, exit, activation handlers)
+- 💬 Approach: Present the journey of collaborative creation while building technical structure
+- 📋 Generate YAML that accurately reflects all discoveries from previous steps
+
+## EXECUTION PROTOCOLS:
+
+- 🎯 Generate complete YAML structure based on agent type and discovered elements
+- 💾 Present complete YAML with proper formatting and explanation
+- 📖 Load appropriate template for agent type for structure guidance
+- 🚫 FORBIDDEN to proceed without incorporating all discovered elements
+
+## CONTEXT BOUNDARIES:
+
+- Available context: All discoveries from previous steps (purpose, persona, capabilities, identity)
+- Focus: YAML generation and complete agent configuration
+- Limits: No validation yet, just YAML generation
+- Dependencies: Complete understanding of all agent characteristics from previous steps
+
+## Sequence of Instructions (Do not deviate, skip, or optimize)
+
+### 1. Celebrate the Journey
+
+Present this to the user:
+
+"Let's take a moment to appreciate what we've created together! Your agent started as an idea, and through our discovery process, it has developed into a fully-realized personality with clear purpose, capabilities, and identity."
+
+**Journey Summary:**
+
+- Started with purpose discovery (Step 2)
+- Shaped personality through four-field persona system (Step 3)
+- Built capabilities and command structure (Step 4)
+- Established name and identity (Step 5)
+- Ready to bring it all together in complete YAML
+
+### 2. Load Agent Type Template
+
+Based on determined agent type, load appropriate template:
+
+- Simple Agent: `agent-complete-simple.md`
+- Expert Agent: `agent-complete-expert.md`
+- Module Agent: `agent-complete-module.md`
+
+### 3. YAML Structure Generation
+
+Explain the core structure to user:
+
+"I'll now generate the complete YAML that incorporates everything we've discovered. This will include your agent's metadata, persona, capabilities, and configuration."
+
+### 4. Generate Complete YAML
+
+Create the complete YAML incorporating all discovered elements:
+
+**Core Structure:**
+
+- Agent metadata (name, title, icon, module, type)
+- Complete persona (role, identity, communication_style, principles)
+- Agent type-specific sections
+- Command structure with proper references
+- Output path configuration
+
+Present the complete YAML to user:
+
+"Here is your complete agent YAML, incorporating everything we've discovered together:
+
+[Display complete YAML with proper formatting]
+
+**Key Features Included:**
+
+- Purpose-driven role and identity
+- Distinct personality with four-field persona system
+- All capabilities we discussed
+- Proper command structure
+- Agent type-specific optimizations
+- Complete metadata and configuration
+
+Does this capture everything we discussed?"
+
+### 5. Agent Type Specific Implementation
+
+Ensure proper implementation based on agent type:
+
+**Simple Agent:**
+
+- All capabilities in YAML prompts section
+- No external file references
+- Self-contained execution logic
+
+**Expert Agent:**
+
+- Sidecar file references for knowledge base
+- Memory integration points
+- Personal workflow capabilities
+
+**Module Agent:**
+
+- Workflow orchestration capabilities
+- Team integration references
+- Cross-agent coordination
+
+### 6. Document Complete YAML
+
+#### Content to Append (if applicable):
+
+```markdown
+## Complete Agent YAML
+
+### Agent Type
+
+[Simple/Expert/Module as determined]
+
+### Generated Configuration
+
+[Complete YAML structure with all discovered elements]
+
+### Key Features Integrated
+
+- Purpose and role from discovery phase
+- Complete persona with four-field system
+- All capabilities and commands developed
+- Agent name and identity established
+- Type-specific optimizations applied
+
+### Output Configuration
+
+[Proper file paths and configuration based on agent type]
+```
+
+Save this content to `{outputFile}` for reference.
+
+### 7. Present MENU OPTIONS
+
+Display: "**Select an Option:** [A] Advanced Elicitation [P] Party Mode [C] Continue"
+
+#### Menu Handling Logic:
+
+- IF A: Execute {advancedElicitationTask}
+- IF P: Execute {partyModeWorkflow}
+- IF C: Save content to {outputFile}, update frontmatter, then only then load, read entire file, then execute {nextStepFile}
+- IF Any other comments or queries: help user respond then [Redisplay Menu Options](#7-present-menu-options)
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After other menu items execution, return to this menu
+- User can chat or ask questions - always respond and then end with display again of the menu options
+
+## CRITICAL STEP COMPLETION NOTE
+
+ONLY WHEN [C continue option] is selected and [complete YAML generated incorporating all discovered elements], will you then load and read fully `{nextStepFile}` to execute and begin validation.
+
+---
+
+## 🚨 SYSTEM SUCCESS/FAILURE METRICS
+
+### ✅ SUCCESS:
+
+- Complete YAML structure generated for correct agent type
+- All discovered elements properly integrated (purpose, persona, capabilities, identity)
+- Commands correctly structured with proper workflow/action references
+- Agent type specific optimizations implemented appropriately
+- Output paths configured correctly based on agent type
+- User confirms YAML captures all requirements from discovery process
+- Content properly saved to output file
+- Menu presented and user input handled correctly
+
+### ❌ SYSTEM FAILURE:
+
+- Duplicating auto-injected features (help, exit, activation handlers)
+- Not incorporating all discovered elements from previous steps
+- Invalid YAML syntax or structure
+- Incorrect agent type implementation
+- Missing user confirmation on YAML completeness
+
+**Master Rule:** Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.