@zeyue0329/xiaoma-cli 1.6.4 → 1.7.0

package/src/xmc/workflows/xiaoma-quick-flow/xiaoma-quick-spec/steps/step-02-investigate.md

@@ -0,0 +1,140 @@
+---
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+# Step 2: Map Technical Constraints & Anchor Points
+
+**Progress: Step 2 of 4** - Next: Generate Plan
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- MUST NOT generate the full spec yet (that's Step 3).
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## CONTEXT:
+
+- Requires `{wipFile}` from Step 1 with the "Problem Statement" defined.
+- Focus: Map the problem statement to specific anchor points in the codebase.
+- Output: Exact files to touch, classes/patterns to extend, and technical constraints identified.
+- Objective: Provide the implementation-ready ground truth for the plan.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load Current State
+
+**Read `{wipFile}` and extract:**
+
+- Problem statement and scope from Overview section
+- Any context gathered in Step 1
+
+### 2. Execute Investigation Path
+
+**Universal Code Investigation:**
+
+_Isolate deep exploration in sub-agents/tasks where available. Return distilled summaries only to prevent context snowballing._
+
+a) **Build on Step 1's Quick Scan**
+
+Review what was found in Step 1's orient scan. Then ask:
+
+"Based on my quick look, I see [files/patterns found]. Are there other files or directories I should investigate deeply?"
+
+b) **Read and Analyze Code**
+
+For each file/directory provided:
+
+- Read the complete file(s)
+- Identify patterns, conventions, coding style
+- Note dependencies and imports
+- Find related test files
+
+**If NO relevant code is found (Clean Slate):**
+
+- Identify the target directory where the feature should live.
+- Scan parent directories for architectural context.
+- Identify standard project utilities or boilerplate that SHOULD be used.
+- Document this as "Confirmed Clean Slate" - establishing that no legacy constraints exist.
+
+
+c) **Document Technical Context**
+
+Capture and confirm with user:
+
+- **Tech Stack**: Languages, frameworks, libraries
+- **Code Patterns**: Architecture patterns, naming conventions, file structure
+- **Files to Modify/Create**: Specific files that will need changes or new files to be created
+- **Test Patterns**: How tests are structured, test frameworks used
+
+d) **Look for project-context.md**
+
+If `**/project-context.md` exists and wasn't loaded in Step 1:
+
+- Load it now
+- Extract patterns and conventions
+- Note any rules that must be followed
+
+### 3. Update WIP File
+
+**Update `{wipFile}` frontmatter:**
+
+```yaml
+---
+# ... existing frontmatter ...
+stepsCompleted: [1, 2]
+tech_stack: ['{captured_tech_stack}']
+files_to_modify: ['{captured_files}']
+code_patterns: ['{captured_patterns}']
+test_patterns: ['{captured_test_patterns}']
+---
+```
+
+**Update the Context for Development section:**
+
+Fill in:
+
+- Codebase Patterns (from investigation)
+- Files to Reference table (files reviewed)
+- Technical Decisions (any decisions made during investigation)
+
+**Report to user:**
+
+"**Context Gathered:**
+
+- Tech Stack: {tech_stack_summary}
+- Files to Modify: {files_count} files identified
+- Patterns: {patterns_summary}
+- Tests: {test_patterns_summary}"
+
+### 4. Present Checkpoint Menu
+
+Display: "**Select:** [A] Advanced Elicitation [P] Party Mode [C] Continue to Generate Spec (Step 3 of 4)"
+
+**HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF A: Invoke the `xiaoma-advanced-elicitation` skill with current tech-spec content, process enhanced insights, ask user "Accept improvements? (y/n)", if yes update WIP file then redisplay menu, if no keep original then redisplay menu
+- IF P: Invoke the `xiaoma-party-mode` skill with current tech-spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update WIP file then redisplay menu, if no keep original then redisplay menu
+- IF C: Verify frontmatter updated with `stepsCompleted: [1, 2]`, then read fully and follow: `./step-03-generate.md`
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to next step when user selects 'C'
+- After A or P execution, return to this menu
+
+---
+
+## REQUIRED OUTPUTS:
+
+- MUST document technical context (stack, patterns, files identified).
+- MUST update `{wipFile}` with functional context.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] Technical mapping performed and documented.
+- [ ] `stepsCompleted: [1, 2]` set in frontmatter.

package/src/xmc/workflows/xiaoma-quick-flow/xiaoma-quick-spec/steps/step-03-generate.md

@@ -0,0 +1,123 @@
+---
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+# Step 3: Generate Implementation Plan
+
+**Progress: Step 3 of 4** - Next: Review & Finalize
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- MUST NOT implement anything - just document.
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## CONTEXT:
+
+- Requires `{wipFile}` with defined "Overview" and "Context for Development" sections.
+- Focus: Create the implementation sequence that addresses the requirement delta using the captured technical context.
+- Output: Implementation-ready tasks with specific files and instructions.
+- Target: Meet the **READY FOR DEVELOPMENT** standard defined in `workflow.md`.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load Current State
+
+**Read `{wipFile}` completely and extract:**
+
+- All frontmatter values
+- Overview section (Problem, Solution, Scope)
+- Context for Development section (Patterns, Files, Decisions)
+
+### 2. Generate Implementation Plan
+
+Generate specific implementation tasks:
+
+a) **Task Breakdown**
+
+- Each task should be a discrete, completable unit of work
+- Tasks should be ordered logically (dependencies first)
+- Include the specific files to modify in each task
+- Be explicit about what changes to make
+
+b) **Task Format**
+
+```markdown
+- [ ] Task N: Clear action description
+  - File: `path/to/file.ext`
+  - Action: Specific change to make
+  - Notes: Any implementation details
+```
+
+### 3. Generate Acceptance Criteria
+
+**Create testable acceptance criteria:**
+
+Each AC should follow Given/When/Then format:
+
+```markdown
+- [ ] AC N: Given [precondition], when [action], then [expected result]
+```
+
+**Ensure ACs cover:**
+
+- Happy path functionality
+- Error handling
+- Edge cases (if relevant)
+- Integration points (if relevant)
+
+### 4. Complete Additional Context
+
+**Fill in remaining sections:**
+
+a) **Dependencies**
+
+- External libraries or services needed
+- Other tasks or features this depends on
+- API or data dependencies
+
+b) **Testing Strategy**
+
+- Unit tests needed
+- Integration tests needed
+- Manual testing steps
+
+c) **Notes**
+
+- High-risk items from pre-mortem analysis
+- Known limitations
+- Future considerations (out of scope but worth noting)
+
+### 5. Write Complete Spec
+
+a) **Update `{wipFile}` with all generated content:**
+
+- Ensure all template sections are filled in
+- No placeholder text remaining
+- All frontmatter values current
+- Update status to 'review' (NOT 'ready-for-dev' - that happens after user review in Step 4)
+
+b) **Update frontmatter:**
+
+```yaml
+---
+# ... existing values ...
+status: 'review'
+stepsCompleted: [1, 2, 3]
+---
+```
+
+c) **Read fully and follow: `./step-04-review.md` (Step 4)**
+
+## REQUIRED OUTPUTS:
+
+- Tasks MUST be specific, actionable, ordered logically, with files to modify.
+- ACs MUST be testable, using Given/When/Then format.
+- Status MUST be updated to 'review'.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] `stepsCompleted: [1, 2, 3]` set in frontmatter.
+- [ ] Spec meets the **READY FOR DEVELOPMENT** standard.

package/src/xmc/workflows/xiaoma-quick-flow/xiaoma-quick-spec/steps/step-04-review.md

@@ -0,0 +1,195 @@
+---
+wipFile: '{implementation_artifacts}/tech-spec-wip.md'
+---
+
+# Step 4: Review & Finalize
+
+**Progress: Step 4 of 4** - Final Step
+
+## RULES:
+
+- MUST NOT skip steps.
+- MUST NOT optimize sequence.
+- MUST follow exact instructions.
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+## CONTEXT:
+
+- Requires `{wipFile}` from Step 3. 
+- MUST present COMPLETE spec content. Iterate until user is satisfied.
+- **Criteria**: The spec MUST meet the **READY FOR DEVELOPMENT** standard defined in `workflow.md`.
+
+## SEQUENCE OF INSTRUCTIONS
+
+### 1. Load and Present Complete Spec
+
+**Read `{wipFile}` completely and extract `slug` from frontmatter for later use.**
+
+**Present to user:**
+
+"Here's your complete tech-spec. Please review:"
+
+[Display the complete spec content - all sections]
+
+"**Quick Summary:**
+
+- {task_count} tasks to implement
+- {ac_count} acceptance criteria to verify
+- {files_count} files to modify"
+
+**Present review menu:**
+
+Display: "**Select:** [C] Continue [E] Edit [Q] Questions [A] Advanced Elicitation [P] Party Mode"
+
+**HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF C: Proceed to Section 3 (Finalize the Spec)
+- IF E: Proceed to Section 2 (Handle Review Feedback), then return here and redisplay menu
+- IF Q: Answer questions, then redisplay this menu
+- IF A: Invoke the `xiaoma-advanced-elicitation` skill with current spec content, process enhanced insights, ask user "Accept improvements? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF P: Invoke the `xiaoma-party-mode` skill with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- ONLY proceed to finalize when user selects 'C'
+- After other menu items execution, return to this menu
+
+### 2. Handle Review Feedback
+
+a) **If user requests changes:**
+
+- Make the requested edits to `{wipFile}`
+- Re-present the affected sections
+- Ask if there are more changes
+- Loop until user is satisfied
+
+b) **If the spec does NOT meet the "Ready for Development" standard:**
+
+- Point out the missing/weak sections (e.g., non-actionable tasks, missing ACs).
+- Propose specific improvements to reach the standard.
+- Make the edits once the user agrees.
+
+c) **If user has questions:**
+
+- Answer questions about the spec
+- Clarify any confusing sections
+- Make clarifying edits if needed
+
+### 3. Finalize the Spec
+
+**When user confirms the spec is good AND it meets the "Ready for Development" standard:**
+
+a) Update `{wipFile}` frontmatter:
+
+   ```yaml
+   ---
+   # ... existing values ...
+   status: 'ready-for-dev'
+   stepsCompleted: [1, 2, 3, 4]
+   ---
+   ```
+
+b) **Rename WIP file to final filename:**
+   - Using the `slug` extracted in Section 1
+   - Rename `{wipFile}` → `{implementation_artifacts}/tech-spec-{slug}.md`
+   - Store this as `finalFile` for use in menus below
+
+### 4. Present Final Menu
+
+a) **Display completion message and menu:**
+
+```
+**Tech-Spec Complete!**
+
+Saved to: {finalFile}
+
+---
+
+**Next Steps:**
+
+[A] Advanced Elicitation - refine further
+[R] Adversarial Review - critique of the spec (highly recommended)
+[B] Begin Development - start implementing now (not recommended)
+[D] Done - exit workflow
+[P] Party Mode - get expert feedback before dev
+
+---
+
+Once you are fully satisfied with the spec (ideally after **Adversarial Review** and maybe a few rounds of **Advanced Elicitation**), it is recommended to run implementation in a FRESH CONTEXT for best results.
+
+Copy this prompt to start dev:
+
+\`\`\`
+quick-dev {finalFile}
+\`\`\`
+
+This ensures the dev agent has clean context focused solely on implementation.
+```
+
+b) **HALT and wait for user selection.**
+
+#### Menu Handling Logic:
+
+- IF A: Invoke the `xiaoma-advanced-elicitation` skill with current spec content, process enhanced insights, ask user "Accept improvements? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF B: Invoke the `xiaoma-quick-dev` skill with `{finalFile}` in a fresh context if possible (warn: fresh context is better)
+- IF D: Exit workflow - display final confirmation and path to spec
+- IF P: Invoke the `xiaoma-party-mode` skill with current spec content, process collaborative insights, ask user "Accept changes? (y/n)", if yes update spec then redisplay menu, if no keep original then redisplay menu
+- IF R: Execute Adversarial Review (see below)
+- IF Any other comments or queries: respond helpfully then redisplay menu
+
+#### EXECUTION RULES:
+
+- ALWAYS halt and wait for user input after presenting menu
+- After A, P, or R execution, return to this menu
+
+#### Adversarial Review [R] Process:
+
+1. **Invoke Adversarial Review Skill**:
+       > With `{finalFile}` constructed, invoke the `xiaoma-review-adversarial-general` skill. If possible, use information asymmetry: invoke the skill in a separate subagent or process with read access to the project, but no context except the `{finalFile}`.
+       > Pass `{finalFile}` as the content to review. The skill should return a list of findings.
+
+    2. **Process Findings**:
+       > Capture the findings from the skill output.
+       > **If zero findings:** HALT - this is suspicious. Re-analyze or request user guidance.
+       > Evaluate severity (Critical, High, Medium, Low) and validity (real, noise, undecided).
+       > DO NOT exclude findings based on severity or validity unless explicitly asked to do so.
+       > Order findings by severity.
+       > Number the ordered findings (F1, F2, F3, etc.).
+       > If TodoWrite or similar tool is available, turn each finding into a TODO, include ID, severity, validity, and description in the TODO; otherwise present findings as a table with columns: ID, Severity, Validity, Description
+
+    3. Return here and redisplay menu.
+
+### 5. Exit Workflow
+
+**When user selects [D]:**
+
+"**All done!** Your tech-spec is ready at:
+
+`{finalFile}`
+
+When you're ready to implement, run:
+
+```
+quick-dev {finalFile}
+```
+
+Ship it!"
+
+---
+
+## REQUIRED OUTPUTS:
+
+- MUST update status to 'ready-for-dev'.
+- MUST rename file to `tech-spec-{slug}.md`.
+- MUST provide clear next-step guidance and recommend fresh context for dev.
+
+## VERIFICATION CHECKLIST:
+
+- [ ] Complete spec presented for review.
+- [ ] Requested changes implemented.
+- [ ] Spec verified against **READY FOR DEVELOPMENT** standard.
+- [ ] `stepsCompleted: [1, 2, 3, 4]` set and file renamed.

package/src/xmc/workflows/xiaoma-quick-flow/xiaoma-quick-spec/workflow.md

@@ -0,0 +1,72 @@
+---
+main_config: '{project-root}/_xiaoma/xmc/config.yaml'
+---
+
+# Quick-Spec Workflow
+
+**Goal:** Create implementation-ready technical specifications through conversational discovery, code investigation, and structured documentation.
+
+**READY FOR DEVELOPMENT STANDARD:**
+
+A specification is considered "Ready for Development" ONLY if it meets the following:
+
+- **Actionable**: Every task has a clear file path and specific action.
+- **Logical**: Tasks are ordered by dependency (lowest level first).
+- **Testable**: All ACs follow Given/When/Then and cover happy path and edge cases.
+- **Complete**: All investigation results from Step 2 are inlined; no placeholders or "TBD".
+- **Self-Contained**: A fresh agent can implement the feature without reading the workflow history.
+
+---
+
+**Your Role:** You are an elite developer and spec engineer. You ask sharp questions, investigate existing code thoroughly, and produce specs that contain ALL context a fresh dev agent needs to implement the feature. No handoffs, no missing context - just complete, actionable specs.
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **step-file architecture** for disciplined execution:
+
+### Core Principles
+
+- **Micro-file Design**: Each step is a self-contained instruction file that must be followed exactly
+- **Just-In-Time Loading**: Only the current step file is in memory - never load future step files until directed
+- **Sequential Enforcement**: Sequence within step files must be completed in order, no skipping or optimization
+- **State Tracking**: Document progress in output file frontmatter using `stepsCompleted` array
+- **Append-Only Building**: Build the tech-spec by updating content as directed
+
+### Step Processing Rules
+
+1. **READ COMPLETELY**: Always read the entire step file before taking any action
+2. **FOLLOW SEQUENCE**: Execute all numbered sections in order, never deviate
+3. **WAIT FOR INPUT**: If a menu is presented, halt and wait for user selection
+4. **CHECK CONTINUATION**: Only proceed to next step when user selects [C] (Continue)
+5. **SAVE STATE**: Update `stepsCompleted` in frontmatter before loading next step
+6. **LOAD NEXT**: When directed, read fully and follow the next step file
+
+### Critical Rules (NO EXCEPTIONS)
+
+- **NEVER** load multiple step files simultaneously
+- **ALWAYS** read entire step file before execution
+- **NEVER** skip steps or optimize the sequence
+- **ALWAYS** update frontmatter of output file when completing a step
+- **ALWAYS** follow the exact instructions in the step file
+- **ALWAYS** halt at menus and wait for user input
+- **NEVER** create mental todo lists from future steps
+
+---
+
+## INITIALIZATION SEQUENCE
+
+### 1. Configuration Loading
+
+Load and read full config from `{main_config}` and resolve:
+
+- `project_name`, `planning_artifacts`, `implementation_artifacts`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime
+- `project_context` = `**/project-context.md` (load if exists)
+- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
+
+### 2. First Step Execution
+
+Read fully and follow: `./steps/step-01-understand.md` to begin the workflow.

package/src/xmc/workflows/xiaoma-quick-flow/xiaoma-quick-spec/xiaoma-skill-manifest.yaml

@@ -0,0 +1 @@
+type: skill

package/tools/cli/README.md

@@ -1,14 +1,14 @@
-# XiaoMa CLI Tool
+# BMad CLI Tool
 
-## Installing external repo XiaoMa official modules
+## Installing external repo BMad official modules
 
 For external official modules to be discoverable during install, ensure an entry for the external repo is added to external-official-modules.yaml.
 
-For community modules - this will be handled in a different way. This file is only for registration of modules under the xiaoma-code-org.
+For community modules - this will be handled in a different way. This file is only for registration of modules under the bmad-code-org.
 
 ## Post-Install Notes
 
-Modules can display setup guidance to users after configuration is collected during `npx xiaoma-cli install`. Notes are defined in the module's own `module.yaml` — no changes to the installer are needed.
+Modules can display setup guidance to users after configuration is collected during `npx bmad-method install`. Notes are defined in the module's own `module.yaml` — no changes to the installer are needed.
 
 ### Simple Format
 

package/tools/cli/commands/install.js

@@ -29,7 +29,7 @@ module.exports = {
     try {
       // Set debug flag as environment variable for all components
       if (options.debug) {
-        process.env.XiaoMa_DEBUG_MANIFEST = 'true';
+        process.env.XIAOMA_DEBUG_MANIFEST = 'true';
         await prompts.log.info('Debug mode enabled');
       }
 

package/tools/cli/commands/status.js

@@ -10,7 +10,7 @@ const ui = new UI();
 
 module.exports = {
   command: 'status',
-  description: 'Display XiaoMa installation status and module versions',
+  description: 'Display XIAOMA installation status and module versions',
   options: [],
   action: async (options) => {
     try {
@@ -21,7 +21,7 @@ module.exports = {
       // Check if xiaoma directory exists
       const fs = require('fs-extra');
       if (!(await fs.pathExists(xiaomaDir))) {
-        await prompts.log.warn('No XiaoMa installation found in the current directory.');
+        await prompts.log.warn('No XIAOMA installation found in the current directory.');
         await prompts.log.message(`Expected location: ${xiaomaDir}`);
         await prompts.log.message('Run "xiaoma install" to set up a new installation.');
         process.exit(0);
@@ -32,7 +32,7 @@ module.exports = {
       const manifestData = await manifest._readRaw(xiaomaDir);
 
       if (!manifestData) {
-        await prompts.log.warn('No XiaoMa installation manifest found.');
+        await prompts.log.warn('No XIAOMA installation manifest found.');
         await prompts.log.message('Run "xiaoma install" to set up a new installation.');
         process.exit(0);
         return;
@@ -56,7 +56,7 @@ module.exports = {
       process.exit(0);
     } catch (error) {
       await prompts.log.error(`Status check failed: ${error.message}`);
-      if (process.env.XiaoMa_DEBUG) {
+      if (process.env.XIAOMA_DEBUG) {
         await prompts.log.message(error.stack);
       }
       process.exit(1);

package/tools/cli/commands/uninstall.js

@@ -7,9 +7,9 @@ const installer = new Installer();
 
 module.exports = {
   command: 'uninstall',
-  description: 'Remove XiaoMa installation from the current project',
+  description: 'Remove XIAOMA installation from the current project',
   options: [
-    ['-y, --yes', 'Remove all XiaoMa components without prompting (preserves user artifacts)'],
+    ['-y, --yes', 'Remove all XIAOMA components without prompting (preserves user artifacts)'],
     ['--directory <path>', 'Project directory (default: current directory)'],
   ],
   action: async (options) => {
@@ -26,7 +26,7 @@ module.exports = {
         // Interactive: ask user which directory to uninstall from
         // select() handles cancellation internally (exits process)
         const dirChoice = await prompts.select({
-          message: 'Where do you want to uninstall XiaoMa from?',
+          message: 'Where do you want to uninstall XIAOMA from?',
           choices: [
             { value: 'cwd', name: `Current directory (${process.cwd()})` },
             { value: 'other', name: 'Another directory...' },
@@ -57,7 +57,7 @@ module.exports = {
       const { xiaomaDir } = await installer.findXiaomaDir(projectDir);
 
       if (!(await fs.pathExists(xiaomaDir))) {
-        await prompts.log.warn('No XiaoMa installation found.');
+        await prompts.log.warn('No XIAOMA installation found.');
         process.exit(0);
       }
 
@@ -68,7 +68,7 @@ module.exports = {
 
       const outputFolder = await installer.getOutputFolder(projectDir);
 
-      await prompts.intro('XiaoMa Uninstall');
+      await prompts.intro('XIAOMA Uninstall');
       await prompts.note(`Version: ${version}\nModules: ${modules}\nIDE integrations: ${ides}`, 'Current Installation');
 
       let removeModules = true;
@@ -82,7 +82,7 @@ module.exports = {
           options: [
             {
               value: 'modules',
-              label: `XiaoMa Modules & data (${installer.xiaomaFolderName}/)`,
+              label: `XIAOMA Modules & data (${installer.bmadFolderName}/)`,
               hint: 'Core installation, agents, workflows, config',
             },
             { value: 'ide', label: 'IDE integrations', hint: ides || 'No IDEs configured' },
@@ -133,10 +133,10 @@ module.exports = {
         s.stop('User artifacts removed');
       }
 
-      // Phase 3: XiaoMa modules & data (last — other phases may need _xiaoma/)
+      // Phase 3: XIAOMA modules & data (last — other phases may need _xiaoma/)
       if (removeModules) {
         const s = await prompts.spinner();
-        s.start(`Removing XiaoMa modules & data (${installer.xiaomaFolderName}/)...`);
+        s.start(`Removing XIAOMA modules & data (${installer.bmadFolderName}/)...`);
         await installer.uninstallModules(projectDir);
         s.stop('Modules & data removed');
       }
@@ -148,7 +148,7 @@ module.exports = {
       if (!removeOutputFolder) summary.push(`User artifacts preserved in ${outputFolder}/`);
 
       await prompts.note(summary.join('\n'), 'Summary');
-      await prompts.outro('To reinstall, run: npx xiaoma-cli install');
+      await prompts.outro('To reinstall, run: npx @zeyue0329/xiaoma-cli install');
 
       process.exit(0);
     } catch (error) {