@zeyue0329/xiaoma-cli 1.0.49 → 1.6.4

package/src/core/_module-installer/installer.js

@@ -0,0 +1,60 @@
+const chalk = require('chalk');
+
+/**
+ * Core Module Installer
+ * Standard module installer function that executes after IDE installations
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from install-config.yaml
+ * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { projectRoot, config, installedIDEs, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🏗️  Installing Core Module...'));
+
+    // Core agent configs are created by the main installer's createAgentConfigs method
+    // No need to create them here - they'll be handled along with all other agents
+
+    // Handle IDE-specific configurations if needed
+    if (installedIDEs && installedIDEs.length > 0) {
+      logger.log(chalk.cyan(`Configuring Core for IDEs: ${installedIDEs.join(', ')}`));
+
+      // Add any IDE-specific Core configurations here
+      for (const ide of installedIDEs) {
+        await configureForIDE(ide, projectRoot, config, logger);
+      }
+    }
+
+    logger.log(chalk.green('✓ Core Module installation complete'));
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing Core module: ${error.message}`));
+    return false;
+  }
+}
+
+/**
+ * Configure Core module for specific IDE
+ * @private
+ */
+async function configureForIDE(ide) {
+  // Add IDE-specific configurations here
+  switch (ide) {
+    case 'claude-code': {
+      // Claude Code specific Core configurations
+      break;
+    }
+    // Add more IDEs as needed
+    default: {
+      // No specific configuration needed
+      break;
+    }
+  }
+}
+
+module.exports = { install };

package/src/core/agents/xiaoma-master.agent.yaml

@@ -0,0 +1,30 @@
+# XiaoMa Master Task Executor Agent
+# Core system agent for task execution and resource management
+
+agent:
+  metadata:
+    id: "_xiaoma/core/agents/xiaoma-master.md"
+    name: "XiaoMa Master"
+    title: "XiaoMa Master Executor, Knowledge Custodian, and Workflow Orchestrator"
+    icon: "🧙"
+    capabilities: "runtime resource management, workflow orchestration, task execution, knowledge custodian"
+    hasSidecar: false
+
+  persona:
+    role: "Master Task Executor + XiaoMa Expert + Guiding Facilitator Orchestrator"
+    identity: "Master-level expert in the XiaoMa Core Platform and all loaded modules with comprehensive knowledge of all resources, tasks, and workflows. Experienced in direct task execution and runtime resource management, serving as the primary execution engine for XiaoMa operations."
+    communication_style: "Direct and comprehensive, refers to himself in the 3rd person. Expert-level communication focused on efficient task execution, presenting information systematically using numbered lists with immediate command response capability."
+    principles: |
+      - Load resources at runtime, never pre-load, and always present numbered lists for choices.
+
+  critical_actions:
+    - 'Always greet the user and let them know they can invoke the `xiaoma-help` skill at any time to get advice on what to do next, and they can combine it with what they need help with <example>Invoke the `xiaoma-help` skill with a question like "where should I start with an idea I have that does XYZ?"</example>'
+
+  menu:
+    - trigger: "LT or fuzzy match on list-tasks"
+      action: "list all tasks from {project-root}/_xiaoma/_config/task-manifest.csv"
+      description: "[LT] List Available Tasks"
+
+    - trigger: "LW or fuzzy match on list-workflows"
+      action: "list all workflows from {project-root}/_xiaoma/_config/workflow-manifest.csv"
+      description: "[LW] List Workflows"

package/src/core/agents/xiaoma-skill-manifest.yaml

@@ -0,0 +1,3 @@
+canonicalId: xiaoma-master
+type: agent
+description: "XiaoMa Master Executor, Knowledge Custodian, and Workflow Orchestrator"

package/src/core/agents/xiaoma-web-orchestrator.agent.xml

@@ -0,0 +1,113 @@
+<agent id="{xiaoma_folder}/core/agents/xiaoma-orchestrator.md" name="XiaoMa Orchestrator" title="XiaoMa Web Orchestrator" icon="🎭" localskip="true">
+  <activation critical="MANDATORY">
+    <step n="1">Load this complete web bundle XML - you are the XiaoMa Orchestrator, first agent in this bundle</step>
+    <step n="2">CRITICAL: This bundle contains ALL agents as XML nodes with id="{xiaoma_folder}/..." and ALL workflows/tasks as nodes findable
+      by type
+      and id</step>
+    <step n="3">Greet user as XiaoMa Orchestrator and display numbered list of ALL menu items from menu section below</step>
+    <step n="4">STOP and WAIT for user input - do NOT execute menu items automatically - accept number or trigger text</step>
+    <step n="5">On user input: Number → execute menu item[n] | Text → case-insensitive substring match | Multiple matches → ask user to
+      clarify | No match → show "Not recognized"</step>
+    <step n="6">When executing a menu item: Check menu-handlers section below for UNIVERSAL handler instructions that apply to ALL agents</step>
+
+    <menu-handlers critical="UNIVERSAL_FOR_ALL_AGENTS">
+      <extract>workflow, exec, tmpl, data, action, validate-workflow</extract>
+      <handlers>
+        <handler type="workflow">
+          When menu item has: workflow="workflow-id"
+          1. Find workflow node by id in this bundle (e.g., &lt;workflow id="workflow-id"&gt;)
+          2. CRITICAL: Always LOAD {xiaoma_folder}/core/tasks/workflow.xml if referenced
+          3. Execute the workflow content precisely following all steps
+          4. Save outputs after completing EACH workflow step (never batch)
+          5. If workflow id is "todo", inform user it hasn't been implemented yet
+        </handler>
+
+        <handler type="exec">
+          When menu item has: exec="node-id" or exec="inline-instruction"
+          1. If value looks like a path/id → Find and execute node with that id
+          2. If value is text → Execute as direct instruction
+          3. Follow ALL instructions within loaded content EXACTLY
+        </handler>
+
+        <handler type="tmpl">
+          When menu item has: tmpl="template-id"
+          1. Find template node by id in this bundle and pass it to the exec, task, action, or workflow being executed
+        </handler>
+
+        <handler type="data">
+          When menu item has: data="data-id"
+          1. Find data node by id in this bundle
+          2. Parse according to node type (json/yaml/xml/csv)
+          3. Make available as {data} variable for subsequent operations
+        </handler>
+
+        <handler type="action">
+          When menu item has: action="#prompt-id" or action="inline-text"
+          1. If starts with # → Find prompt with matching id in current agent
+          2. Otherwise → Execute the text directly as instruction
+        </handler>
+
+        <handler type="validate-workflow">
+          When menu item has: validate-workflow="workflow-id"
+          1. MUST LOAD {xiaoma_folder}/core/tasks/validate-workflow.xml
+          2. Execute all validation instructions from that file
+          3. Check workflow's validation property for schema
+          4. Identify file to validate or ask user to specify
+        </handler>
+      </handlers>
+    </menu-handlers>
+
+    <orchestrator-specific>
+      <agent-transformation critical="true">
+        When user selects *agents [agent-name]:
+        1. Find agent XML node with matching name/id in this bundle
+        2. Announce transformation: "Transforming into [agent name]... 🎭"
+        3. BECOME that agent completely:
+        - Load and embody their persona/role/communication_style
+        - Display THEIR menu items (not orchestrator menu)
+        - Execute THEIR commands using universal handlers above
+        4. Stay as that agent until user types *exit
+        5. On *exit: Confirm, then return to XiaoMa Orchestrator persona
+      </agent-transformation>
+
+      <list-agents critical="true">
+        When user selects *list-agents:
+        1. Scan all agent nodes in this bundle
+        2. Display formatted list with:
+        - Number, emoji, name, title
+        - Brief description of capabilities
+        - Main menu items they offer
+        3. Suggest which agent might help with common tasks
+      </list-agents>
+    </orchestrator-specific>
+
+    <rules>
+      Web bundle environment - NO file system access, all content in XML nodes
+      Find resources by XML node id/type within THIS bundle only
+      Use canvas for document drafting when available
+      Menu triggers use asterisk (*) - display exactly as shown
+      Number all lists, use letters for sub-options
+      Stay in character (current agent) until *exit command
+      Options presented as numbered lists with descriptions
+      elicit="true" attributes require user confirmation before proceeding
+    </rules>
+  </activation>
+
+  <persona>
+    <role>Master Orchestrator and XiaoMa Scholar</role>
+    <identity>Master orchestrator with deep expertise across all loaded agents and workflows. Technical brilliance balanced with
+      approachable communication.</identity>
+    <communication_style>Knowledgeable, guiding, approachable, very explanatory when in XiaoMa Orchestrator mode</communication_style>
+    <core_principles>When I transform into another agent, I AM that agent until *exit command received. When I am NOT transformed into
+      another agent, I will give you guidance or suggestions on a workflow based on your needs.</core_principles>
+  </persona>
+  <menu>
+    <item cmd="*help">Show numbered command list</item>
+    <item cmd="*list-agents">List all available agents with their capabilities</item>
+    <item cmd="*agents [agent-name]">Transform into a specific agent</item>
+    <item cmd="*party-mode" exec="{xiaoma_folder}/core/workflows/party-mode/workflow.md">Enter group chat with all agents
+      simultaneously</item>
+    <item cmd="*advanced-elicitation" task="{xiaoma_folder}/core/tasks/advanced-elicitation.xml">Push agent to perform advanced elicitation</item>
+    <item cmd="*exit">Exit current session</item>
+  </menu>
+</agent>

package/src/core/module-help.csv

@@ -0,0 +1,10 @@
+module,phase,name,code,sequence,workflow-file,command,required,agent,options,description,output-location,outputs
+core,anytime,Brainstorming,BSP,,_xiaoma/core/workflows/brainstorming/workflow.md,xiaoma-brainstorming,false,analyst,,"Generate diverse ideas through interactive techniques. Use early in ideation phase or when stuck generating ideas.",{output_folder}/brainstorming/brainstorming-session-{{date}}.md,,
+core,anytime,Party Mode,PM,,_xiaoma/core/workflows/party-mode/workflow.md,xiaoma-party-mode,false,party-mode facilitator,,"Orchestrate multi-agent discussions. Use when you need multiple agent perspectives or want agents to collaborate.",,
+core,anytime,xiaoma-help,BH,,skill:xiaoma-help,xiaoma-help,false,,,"Get unstuck by showing what workflow steps come next or answering XiaoMa Method questions.",,
+core,anytime,Index Docs,ID,,_xiaoma/core/tasks/index-docs.xml,xiaoma-index-docs,false,,,"Create lightweight index for quick LLM scanning. Use when LLM needs to understand available docs without loading everything.",,
+core,anytime,Shard Document,SD,,_xiaoma/core/tasks/shard-doc.xml,xiaoma-shard-doc,false,,,"Split large documents into smaller files by sections. Use when doc becomes too large (>500 lines) to manage effectively.",,
+core,anytime,Editorial Review - Prose,EP,,_xiaoma/core/tasks/editorial-review-prose.xml,xiaoma-editorial-review-prose,false,,,"Review prose for clarity, tone, and communication issues. Use after drafting to polish written content.",report located with target document,"three-column markdown table with suggested fixes",
+core,anytime,Editorial Review - Structure,ES,,_xiaoma/core/tasks/editorial-review-structure.xml,xiaoma-editorial-review-structure,false,,,"Propose cuts, reorganization, and simplification while preserving comprehension. Use when doc produced from multiple subprocesses or needs structural improvement.",report located with target document,
+core,anytime,Adversarial Review (General),AR,,skill:xiaoma-review-adversarial-general,xiaoma-review-adversarial-general,false,,,"Review content critically to find issues and weaknesses. Use for quality assurance or before finalizing deliverables. Code Review in other modules run this automatically, but its useful also for document reviews",,
+core,anytime,Edge Case Hunter Review,ECH,,skill:xiaoma-review-edge-case-hunter,xiaoma-review-edge-case-hunter,false,,,"Walk every branching path and boundary condition in code, report only unhandled edge cases. Use alongside adversarial review for orthogonal coverage - method-driven not attitude-driven.",,

package/src/core/module.yaml

@@ -0,0 +1,25 @@
+code: core
+name: "XiaoMa Core Module"
+
+header: "XiaoMa Core Configuration"
+subheader: "Configure the core settings for your XiaoMa installation.\nThese settings will be used across all installed xiaoma skills, workflows, and agents."
+
+user_name:
+  prompt: "What should agents call you? (Use your name or a team name)"
+  default: "XiaoMa"
+  result: "{value}"
+
+communication_language:
+  prompt: "What language should agents use when chatting with you?"
+  default: "English"
+  result: "{value}"
+
+document_output_language:
+  prompt: "Preferred document output language?"
+  default: "English"
+  result: "{value}"
+
+output_folder:
+  prompt: "Where should output files be saved?"
+  default: "_xiaoma-output"
+  result: "{project-root}/{value}"

package/src/core/resources/excalidraw/README.md

@@ -0,0 +1,160 @@
+# Core Excalidraw Resources
+
+Universal knowledge for creating Excalidraw diagrams. All agents that create Excalidraw files should reference these resources.
+
+## Purpose
+
+Provides the **HOW** (universal knowledge) while agents provide the **WHAT** (domain-specific application).
+
+**Core = "How to create Excalidraw elements"**
+
+- How to group shapes with text labels
+- How to calculate text width
+- How to create arrows with proper bindings
+- How to validate JSON syntax
+- Base structure and primitives
+
+**Agents = "What diagrams to create"**
+
+- Frame Expert (XMC): Technical flowcharts, architecture diagrams, wireframes
+- Presentation Master (CIS): Pitch decks, creative visuals, Rube Goldberg machines
+- Tech Writer (XMC): Documentation diagrams, concept explanations
+
+## Files in This Directory
+
+### excalidraw-helpers.md
+
+**Universal element creation patterns**
+
+- Text width calculation
+- Element grouping rules (shapes + labels)
+- Grid alignment
+- Arrow creation (straight, elbow)
+- Theme application
+- Validation checklist
+- Optimization rules
+
+**Agents reference this to:**
+
+- Create properly grouped shapes
+- Calculate text dimensions
+- Connect elements with arrows
+- Ensure valid structure
+
+### validate-json-instructions.md
+
+**Universal JSON validation process**
+
+- How to validate Excalidraw JSON
+- Common errors and fixes
+- Workflow integration
+- Error recovery
+
+**Agents reference this to:**
+
+- Validate files after creation
+- Fix syntax errors
+- Ensure files can be opened in Excalidraw
+
+### library-loader.md (Future)
+
+**How to load external .excalidrawlib files**
+
+- Programmatic library loading
+- Community library integration
+- Custom library management
+
+**Status:** To be developed when implementing external library support.
+
+## How Agents Use These Resources
+
+### Example: Frame Expert (Technical Diagrams)
+
+```yaml
+# workflows/diagrams/create-flowchart/workflow.yaml
+helpers: '{project-root}/{xiaoma_folder}/core/resources/excalidraw/excalidraw-helpers.md'
+json_validation: '{project-root}/{xiaoma_folder}/core/resources/excalidraw/validate-json-instructions.md'
+```
+
+**Domain-specific additions:**
+
+```yaml
+# workflows/diagrams/_shared/flowchart-templates.yaml
+flowchart:
+  start_node:
+    type: ellipse
+    width: 120
+    height: 60
+  process_box:
+    type: rectangle
+    width: 160
+    height: 80
+  decision_diamond:
+    type: diamond
+    width: 140
+    height: 100
+```
+
+### Example: Presentation Master (Creative Visuals)
+
+```yaml
+# workflows/create-visual-metaphor/workflow.yaml
+helpers: '{project-root}/{xiaoma_folder}/core/resources/excalidraw/excalidraw-helpers.md'
+json_validation: '{project-root}/{xiaoma_folder}/core/resources/excalidraw/validate-json-instructions.md'
+```
+
+**Domain-specific additions:**
+
+```yaml
+# workflows/_shared/creative-templates.yaml
+rube_goldberg:
+  whimsical_connector:
+    type: arrow
+    strokeStyle: dashed
+    roughness: 2
+  playful_box:
+    type: rectangle
+    roundness: 12
+```
+
+## What Doesn't Belong in Core
+
+**Domain-Specific Elements:**
+
+- Flowchart-specific templates (belongs in Frame Expert)
+- Pitch deck layouts (belongs in Presentation Master)
+- Documentation-specific styles (belongs in Tech Writer)
+
+**Agent Workflows:**
+
+- How to create a flowchart (Frame Expert workflow)
+- How to create a pitch deck (Presentation Master workflow)
+- Step-by-step diagram creation (agent-specific)
+
+**Theming:**
+
+- Currently in agent workflows
+- **Future:** Will be refactored to core as user-configurable themes
+
+## Architecture Principle
+
+**Single Source of Truth:**
+
+- Core holds universal knowledge
+- Agents reference core, don't duplicate
+- Updates to core benefit all agents
+- Agents specialize with domain knowledge
+
+**DRY (Don't Repeat Yourself):**
+
+- Element creation logic: ONCE in core
+- Text width calculation: ONCE in core
+- Validation process: ONCE in core
+- Arrow binding patterns: ONCE in core
+
+## Future Enhancements
+
+1. **External Library Loader** - Load .excalidrawlib files from libraries.excalidraw.com
+2. **Theme Management** - User-configurable color themes saved in core
+3. **Component Library** - Shared reusable components across agents
+4. **Layout Algorithms** - Auto-layout helpers for positioning elements

package/src/core/resources/excalidraw/excalidraw-helpers.md

@@ -0,0 +1,127 @@
+# Excalidraw Element Creation Guidelines
+
+## Text Width Calculation
+
+For text elements inside shapes (labels):
+
+```
+text_width = (text.length × fontSize × 0.6) + 20
+```
+
+Round to nearest 10 for grid alignment.
+
+## Element Grouping Rules
+
+**CRITICAL:** When creating shapes with labels:
+
+1. Generate unique IDs:
+   - `shape-id` for the shape
+   - `text-id` for the text
+   - `group-id` for the group
+
+2. Shape element must have:
+   - `groupIds: [group-id]`
+   - `boundElements: [{type: "text", id: text-id}]`
+
+3. Text element must have:
+   - `containerId: shape-id`
+   - `groupIds: [group-id]` (SAME as shape)
+   - `textAlign: "center"`
+   - `verticalAlign: "middle"`
+   - `width: calculated_width`
+
+## Grid Alignment
+
+- Snap all `x`, `y` coordinates to 20px grid
+- Formula: `Math.round(value / 20) * 20`
+- Spacing between elements: 60px minimum
+
+## Arrow Creation
+
+### Straight Arrows
+
+Use for forward flow (left-to-right, top-to-bottom):
+
+```json
+{
+  "type": "arrow",
+  "startBinding": {
+    "elementId": "source-shape-id",
+    "focus": 0,
+    "gap": 10
+  },
+  "endBinding": {
+    "elementId": "target-shape-id",
+    "focus": 0,
+    "gap": 10
+  },
+  "points": [[0, 0], [distance_x, distance_y]]
+}
+```
+
+### Elbow Arrows
+
+Use for upward flow, backward flow, or complex routing:
+
+```json
+{
+  "type": "arrow",
+  "startBinding": {...},
+  "endBinding": {...},
+  "points": [
+    [0, 0],
+    [intermediate_x, 0],
+    [intermediate_x, intermediate_y],
+    [final_x, final_y]
+  ],
+  "elbowed": true
+}
+```
+
+### Update Connected Shapes
+
+After creating arrow, update `boundElements` on both connected shapes:
+
+```json
+{
+  "id": "shape-id",
+  "boundElements": [
+    { "type": "text", "id": "text-id" },
+    { "type": "arrow", "id": "arrow-id" }
+  ]
+}
+```
+
+## Theme Application
+
+Theme colors should be applied consistently:
+
+- **Shapes**: `backgroundColor` from theme primary fill
+- **Borders**: `strokeColor` from theme accent
+- **Text**: `strokeColor` = "#1e1e1e" (dark text)
+- **Arrows**: `strokeColor` from theme accent
+
+## Validation Checklist
+
+Before saving, verify:
+
+- [ ] All shapes with labels have matching `groupIds`
+- [ ] All text elements have `containerId` pointing to parent shape
+- [ ] Text width calculated properly (no cutoff)
+- [ ] Text alignment set (`textAlign` + `verticalAlign`)
+- [ ] All elements snapped to 20px grid
+- [ ] All arrows have `startBinding` and `endBinding`
+- [ ] `boundElements` array updated on connected shapes
+- [ ] Theme colors applied consistently
+- [ ] No metadata or history in final output
+- [ ] All IDs are unique
+
+## Optimization
+
+Remove from final output:
+
+- `appState` object
+- `files` object (unless images used)
+- All elements with `isDeleted: true`
+- Unused library items
+- Version history

package/src/core/resources/excalidraw/library-loader.md

@@ -0,0 +1,50 @@
+# External Library Loader
+
+**Status:** Placeholder for future implementation
+
+## Purpose
+
+Load external .excalidrawlib files from <https://libraries.excalidraw.com> or custom sources.
+
+## Planned Capabilities
+
+- Load libraries by URL
+- Load libraries from local files
+- Merge multiple libraries
+- Filter library components
+- Cache loaded libraries
+
+## API Reference
+
+Will document how to use:
+
+- `importLibrary(url)` - Load library from URL
+- `loadSceneOrLibraryFromBlob()` - Load from file
+- `mergeLibraryItems()` - Combine libraries
+
+## Usage Example
+
+```yaml
+# Future workflow.yaml structure
+libraries:
+  - url: 'https://libraries.excalidraw.com/libraries/...'
+    filter: ['aws', 'cloud']
+  - path: '{project-root}/_data/custom-library.excalidrawlib'
+```
+
+## Implementation Notes
+
+This will be developed when agents need to leverage the extensive library ecosystem available at <https://libraries.excalidraw.com>.
+
+Hundreds of pre-built component libraries exist for:
+
+- AWS/Cloud icons
+- UI/UX components
+- Business diagrams
+- Mind map shapes
+- Floor plans
+- And much more...
+
+## User Configuration
+
+Future: Users will be able to configure favorite libraries in their XIAOMA config for automatic loading.

package/src/core/resources/excalidraw/validate-json-instructions.md

@@ -0,0 +1,79 @@
+# JSON Validation Instructions
+
+## Purpose
+
+Validate Excalidraw JSON files after saving to catch syntax errors (missing commas, brackets, quotes).
+
+## How to Validate
+
+Use Node.js built-in JSON parsing to validate the file:
+
+```bash
+node -e "JSON.parse(require('fs').readFileSync('FILE_PATH', 'utf8')); console.log('✓ Valid JSON')"
+```
+
+Replace `FILE_PATH` with the actual file path.
+
+## Exit Codes
+
+- Exit code 0 = Valid JSON
+- Exit code 1 = Invalid JSON (syntax error)
+
+## Error Output
+
+If invalid, Node.js will output:
+
+- Error message with description
+- Position in file where error occurred
+- Line and column information (if available)
+
+## Common Errors and Fixes
+
+### Missing Comma
+
+```
+SyntaxError: Expected ',' or '}' after property value
+```
+
+**Fix:** Add comma after the property value
+
+### Missing Bracket/Brace
+
+```
+SyntaxError: Unexpected end of JSON input
+```
+
+**Fix:** Add missing closing bracket `]` or brace `}`
+
+### Extra Comma (Trailing)
+
+```
+SyntaxError: Unexpected token ,
+```
+
+**Fix:** Remove the trailing comma before `]` or `}`
+
+### Missing Quote
+
+```
+SyntaxError: Unexpected token
+```
+
+**Fix:** Add missing quote around string value
+
+## Workflow Integration
+
+After saving an Excalidraw file, run validation:
+
+1. Save the file
+2. Run: `node -e "JSON.parse(require('fs').readFileSync('{{save_location}}', 'utf8')); console.log('✓ Valid JSON')"`
+3. If validation fails:
+   - Read the error message for line/position
+   - Open the file at that location
+   - Fix the syntax error
+   - Save and re-validate
+4. Repeat until validation passes
+
+## Critical Rule
+
+**NEVER delete the file due to validation errors - always fix the syntax error at the reported location.**