@zeyue0329/xiaoma-cli 1.13.0 → 1.15.0

package/src/xpm-skills/xiaoma-patent-mining/steps/step-04-ai-taste-removal.md

@@ -0,0 +1,85 @@
+# Step 4: Engineer-Style Rewrite (Strip the AI Tone)
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 🛑 Patent agents detect AI-style writing instantly and treat it as a red flag. This pass is not optional.
+- ✅ Apply the substitution table and the self-check list to every section of every disclosure produced in step-03.
+- ⏸️  HALT at the end of this step. Show the user the rewritten draft and wait for explicit approval before generating DOCX in step-05.
+
+## YOUR TASK
+
+Rewrite every disclosure markdown so it reads like a senior engineer's internal RFC, not like AI marketing copy.
+
+## SUBSTITUTION TABLE
+
+Apply these substitutions throughout the document.
+
+| Avoid (AI tone) | Use (engineer tone) |
+| --- | --- |
+| 本发明创造性地提出了 | 本方案采用了 |
+| 显著地提升了性能 | 实测吞吐量提升约40% |
+| 巧妙地解决了 | 通过XX方式解决了 |
+| 革命性的 / 突破性的 | (delete — replace with concrete numbers) |
+| 不可忽视的优势 | 主要改进在于 |
+| 值得注意的是 | (delete — just state the fact) |
+| 在一个实施例中 | 以XX场景为例 |
+| 综上所述 | (delete — write the conclusion directly) |
+| 确保了系统的鲁棒性 | 当XX异常时，系统通过YY机制恢复 |
+| 本发明旨在 | 本方案的目标是 |
+| 进一步地 | 在此基础上 |
+| 需要说明的是 | (delete — just say it) |
+| 可以理解的是 | (delete) |
+| 作为一种可选的实施方式 | 另一种做法是 |
+
+## ENGINEER STYLE CHECKLIST
+
+A real engineer's disclosure tends to:
+
+- Use concrete numbers ("response time dropped from 3s to 200ms" instead of "greatly improved")
+- Name actual technical components ("uses Redis SETNX for the distributed lock")
+- Describe logic in time-ordered steps ("first ..., then ..., finally ...")
+- Justify design decisions ("we chose X over Y because ...")
+- Acknowledge tradeoffs ("this adds ~15% memory overhead, but in exchange ...")
+- Prefer short sentences, paragraphs of 3–6 sentences
+- Mix in English technical terms verbatim (failover, sharding, backpressure)
+- Use parentheses for clarification ("the message queue (RocketMQ in this scheme)")
+
+Reality cues that strengthen authenticity:
+
+- Performance numbers must be plausible (not "1000000x faster")
+- Tech choices must match the stack (a Java project doesn't use Go libraries)
+- One honest sentence about a limitation increases credibility
+- Phrases like "in production" or "under load" anchor the writing
+
+## SELF-CHECK PASS
+
+Go through the document once with this checklist:
+
+- [ ] Any "显著 / 创造性 / 巧妙" left? → delete
+- [ ] Any vague effect claim? → replace with a concrete metric
+- [ ] Any pure principle or pure functional sentence in section 3? → add the implementation detail
+- [ ] Every claimed effect traceable to a specific technical means? → if not, add the causal chain
+- [ ] Terminology consistent (no two names for the same thing)?
+- [ ] All English abbreviations have a Chinese gloss?
+
+## BEFORE / AFTER EXAMPLE
+
+**Before (AI tone, reject):**
+
+> 本发明创造性地提出了一种高效的票据签收处理方法。该方法显著提升了系统的处理能力，巧妙地解决了传统方案中存在的性能瓶颈问题。通过采用先进的批量处理技术，本发明确保了系统在高并发场景下的鲁棒性，实现了革命性的性能突破。
+
+**After (engineer tone, accept):**
+
+> 本方案针对票据签收环节的并发处理问题，采用了请求合并 + 批量校验的方式。具体做法是：将 200ms 时间窗口内到达的签收请求合并为一个批次，对同一承兑人的票据共享额度查询结果，避免重复调用外部征信接口。实测在 300 笔/秒的并发压力下，单笔平均处理耗时从 4.2s 降到了 380ms，数据库查询次数减少约 65%。这种方式会引入最多 200ms 的额外等待，但在票据业务场景下（用户对秒级延迟不敏感）是可接受的。
+
+## HALT
+
+Stop here. Present the rewritten disclosure to the user and ask:
+
+> "Here is the engineer-style disclosure (path: {disclosure_md_file}). Please review section 3.2 in particular — it is what the agent will use to draft the claims. Approve, request edits, or ask to add figures before DOCX generation."
+
+Wait for explicit "approved / generate docx" before loading step-05.
+
+## NEXT STEP
+
+After user approval, load `./step-05-docx-generation.md`.

package/src/xpm-skills/xiaoma-patent-mining/steps/step-05-docx-generation.md

@@ -0,0 +1,111 @@
+# Step 5: DOCX Generation
+
+## MANDATORY EXECUTION RULES (READ FIRST)
+
+- 📖 **Read `references/docx-format-spec.md` first.** It defines fonts, sizes, line spacing, image embedding, and the post-generation grep self-check. Do not deviate from it.
+- ✅ Use `{skill_root}/scripts/md2docx.js` for conversion. It already implements the spec (heading style, header fields, body indent, image embed with IHDR pixel reading, etc.). Do NOT hand-write `ImageRun` or `Paragraph` code.
+- 🛑 Do NOT inline image alt-text as a substitute for an actual image. If `![alt](path)` is in the markdown, the path MUST resolve and the image MUST be embedded.
+
+## YOUR TASK
+
+Convert the approved disclosure markdown(s) to formatted `.docx` files at `{disclosure_docx_file}`.
+
+## EXECUTION SEQUENCE
+
+### 5.1 Verify environment
+
+```bash
+node --version          # need Node 20+
+which node
+test -f "{skill_root}/scripts/md2docx.js" && echo "script ok"
+ls "{patent_output_folder}/media/" 2>/dev/null || echo "no media yet"
+```
+
+The `docx` npm package is required at runtime. Resolution order (do NOT auto-`npm install` in the user's project root — that would pollute their `package.json`):
+
+1. If `docx` already resolves from the user's `{project-root}` (`node -e "require.resolve('docx')"` succeeds), use that.
+2. Otherwise, install it into the skill's own folder so it stays scoped to the skill:
+   ```bash
+   cd "{skill_root}" && npm install --no-save --silent --prefix . docx
+   ```
+3. As a last resort, ask the user to run `npm install -g docx` and re-invoke `PG`.
+
+The script uses `module.paths` fallback when invoked from `{skill_root}`, so step 2 is sufficient.
+
+> **About git hygiene:** the skill ships a `.gitignore` inside `{skill_root}` that excludes `node_modules/`, `package.json`, and `package-lock.json`. If the user's `.gitignore` does NOT already ignore `_xiaoma/`, this local `.gitignore` keeps the `docx` install from being committed.
+
+### 5.2 Verify image references
+
+For each `![alt](relative-path)` in the markdown, confirm the resolved path exists relative to the markdown file. The convention is `media/doc{N}_fig{M}.png` next to the markdown. Missing images will be replaced by a red `[图片缺失]` placeholder by the script — warn the user if any are missing and ask whether to proceed.
+
+### 5.3 Run conversion
+
+```bash
+node "{skill_root}/scripts/md2docx.js" \
+  "{disclosure_md_file}" \
+  "{disclosure_docx_file}"
+```
+
+The script auto-handles:
+
+- The big title "技术交底书" (楷体_GB2312, 18pt, bold, centered)
+- The five header fields (仿宋_GB2312, 10.5pt, bold, left)
+- Section headings (楷体_GB2312, 10.5pt, bold, left)
+- Body paragraphs (宋体, 10.5pt, justified, 1.5x line spacing, 2-char first-line indent)
+- Tables, lists, inline code, code blocks
+- Image embedding with IHDR pixel reading and ≤ 540px width / ≤ 720px height proportional scaling
+- Auto figure captions from alt text (centered, 宋体 10pt italic)
+
+### 5.4 Post-generation self-check (optional but recommended)
+
+A `.docx` file is a zip archive of XML — any unzip tool works. Use `unzip` if available, or fall back to `python -m zipfile -e`:
+
+```bash
+# Pick whichever is available on the host
+unzip -o "{disclosure_docx_file}" -d /tmp/disclosure-unpack/ \
+  || python -m zipfile -e "{disclosure_docx_file}" /tmp/disclosure-unpack/
+
+grep -oE 'w:eastAsia="[^"]+"' /tmp/disclosure-unpack/word/document.xml | sort | uniq -c
+grep -oE 'w:color w:val="[A-F0-9]+"' /tmp/disclosure-unpack/word/document.xml | sort | uniq -c
+ls /tmp/disclosure-unpack/word/media/ 2>/dev/null | wc -l
+```
+
+Expected:
+
+- `仿宋_GB2312` → exactly 5 (the five header fields)
+- `楷体_GB2312` → ≥ number of section headings
+- Everything else → `宋体`
+- Color values → only `000000` (unless blue `0000FF` placeholder hints were intentionally kept)
+- Media file count → equals number of standalone `![](...)` lines in the markdown
+
+If any expectation fails, the docx is non-compliant — fix the source markdown or `md2docx.js` constants and re-run, do not deliver. If neither `unzip` nor `python` is available, deliver the file but flag the missed self-check to the user.
+
+### 5.5 Final filename convention
+
+`专利交底书-<invention-slug>-<YYYYMMDD>.docx`
+
+Save to `{patent_output_folder}/`.
+
+### 5.6 Delivery
+
+Report to the user:
+
+- Final docx path
+- Number of figures embedded
+- Result of the grep self-check
+- Suggested next action: send to the patent agent, or if the agent uses a different template, see "Custom Template Override" below
+
+### 5.7 Custom template override (when client provides a different `.doc`/.docx)
+
+If the user provides a different template `.doc/.docx`:
+
+1. If the file is `.doc`, convert to `.docx` first (e.g., `libreoffice --headless --convert-to docx 模板.doc`)
+2. Unpack the docx (it's a zip): `unzip -o 模板.docx -d /tmp/tmpl/` (or `python -m zipfile -e 模板.docx /tmp/tmpl/`)
+3. Read `/tmp/tmpl/word/styles.xml` (defaults) and `/tmp/tmpl/word/document.xml` (sample paragraphs)
+4. Extract: default font (`rFontsDefault`), line spacing (`spacing.line + lineRule`), first-line indent (`ind.firstLineChars / firstLine`), heading fonts/colors, placeholder hint color
+5. Overwrite the constants at the top of `{skill_root}/scripts/md2docx.js`: `FONT_BODY_EAST / FONT_HEADING_EAST / FONT_TITLE_EAST / FONT_HEADER_FIELD_EAST / SIZE_BODY / SIZE_TITLE / BODY_LINE_SPACING / HEADING_LINE_SPACING / BODY_FIRST_LINE_INDENT`
+6. Re-run step 5.3 and 5.4
+
+## WORKFLOW COMPLETE
+
+After delivery, the skill ends. Recommend the user run a separate session for the next invention point, or invoke `PG` directly to regenerate DOCX from an edited markdown.

package/src/xpm-skills/xiaoma-patent-mining/workflow.md

@@ -0,0 +1,94 @@
+---
+context_file: '' # Optional project root or invention context path passed by the invoking agent
+---
+
+# Patent Mining and Disclosure Generation Workflow
+
+**Goal:** From a complete software project (code, design docs, requirements), mine patentable innovations and produce a prosecution-ready disclosure document (`.docx`) that satisfies the three-element test (technical-problem / technical-means / technical-effect) and is written in the voice of a senior engineer, not AI marketing copy. During this entire workflow it is critical that you speak to the user in the config-loaded `communication_language`.
+
+**Your Role:** You are a senior R&D engineer who has crossed over to patent prosecution. You combine deep engineering reading skill with the discipline of a patent examiner. You refuse to dress up ordinary CRUD or framework usage as inventions, and you refuse to write disclosures in the inflated AI-style that patent agents see and reject every day.
+
+**Critical Mindset:** Treat every candidate invention as guilty until it passes the three-element test. A candidate must have all of:
+
+1. A concrete technical problem (not a business need, not a vague "improve experience")
+2. A non-obvious technical means grounded in natural laws (not pure rules, not pure algorithms on paper, not standard framework features)
+3. A measurable technical effect (latency, throughput, accuracy, resource cost, reliability — with numbers when possible)
+
+Any candidate that cannot fill all three slots crisply is **not** a patent and should be redirected to software copyright (software copyright registration) or dropped.
+
+**Anti-AI-Tone Protocol:** Disclosures are read by patent agents who read dozens per week. They detect AI-generated text instantly. You must write like a staff engineer writing an internal RFC: specific numbers, named components, time-ordered steps, honest tradeoffs. Strip every "significantly", "creatively", "cleverly", "revolutionarily", "in summary".
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This skill uses **micro-file architecture** with five sequential steps:
+
+- `steps/step-01-project-analysis.md` — Project understanding and material collection
+- `steps/step-02-patent-mining.md` — Apply three-element test, produce candidate list (HALT for user confirmation)
+- `steps/step-03-disclosure-writing.md` — Draft the disclosure using the six-section template
+- `steps/step-04-ai-taste-removal.md` — Apply the engineer-style rewrite pass (HALT for user review)
+- `steps/step-05-docx-generation.md` — Generate the formatted DOCX via `scripts/md2docx.js`
+
+Authoritative references (read these before deciding edge cases):
+
+- `references/mining-principles.md` — Three-element test, positive/negative examples, common pitfalls
+- `references/disclosure-template.md` — Six-section disclosure template and per-section guidance
+- `references/docx-format-spec.md` — Font / size / spacing / image embedding rules for the DOCX output
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_xiaoma/core/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `user_name`
+- `communication_language`, `document_output_language`, `user_skill_level`
+- `date` as system-generated current datetime (YYYYMMDD)
+
+Then load `{project-root}/_xiaoma/xpm/config.yaml` and resolve:
+
+- `patent_output_folder` (always present — written by installer)
+- `inventor_name`, `inventor_contact_name`, `inventor_contact_phone`, `inventor_contact_email` — **these keys are typically absent**. The installer does NOT collect them (each disclosure may have different inventors). If the user has manually added any of these keys to `config.yaml`, use them as defaults in step-02; otherwise step-02 will collect them interactively for this disclosure only.
+
+### Paths
+
+- `disclosure_md_file` = `{patent_output_folder}/专利交底书-{{invention-slug}}-{{date}}.md` (evaluated once `invention-slug` is decided in step-02)
+- `disclosure_docx_file` = `{patent_output_folder}/专利交底书-{{invention-slug}}-{{date}}.docx`
+- `media_dir` = `{patent_output_folder}/media`
+- `skill_root` = the directory containing this `workflow.md`. At runtime, after the agent loads this file, resolve `skill_root` as `dirname(<path-from-which-this-workflow.md-was-read>)`. For the installed skill this is `./`. Use it to reach `scripts/md2docx.js` and `references/*.md`.
+
+All steps MUST reference these resolved variables, never re-typing the literal paths.
+
+### Context File
+
+- `context_file` = Optional path passed by the invoking agent. The default `patent-advisor` agent does NOT pass one — step-01 will use the user's current `{project-root}` as the scan root. If a context file is provided (e.g., a saved project-cognition memo from a prior session), prefer it.
+
+---
+
+## ROUTING (TRIGGER DISPATCH)
+
+This skill is shared by three agent triggers (`PM`, `PD`, `PG`). Choose the entry point based on the invoking trigger:
+
+| Trigger | Entry point | Description |
+| --- | --- | --- |
+| `PM` (patent-mining) | `steps/step-01-project-analysis.md` | Full pipeline starting from project analysis |
+| `PD` (patent-disclosure) | `steps/step-03-disclosure-writing.md` | User already knows the invention point. Ask them to describe it in three-element form, then jump to disclosure drafting |
+| `PG` (patent-generate) | `steps/step-05-docx-generation.md` | User has a finished disclosure markdown. Ask for the input md path and target docx path, then run conversion only |
+
+If the trigger is unknown or ambiguous, default to `PM`.
+
+---
+
+## EXECUTION
+
+Read fully and follow the entry-point step above for the invoking trigger.
+
+After each step finishes, load the next step in numeric order (unless the step explicitly routes elsewhere). The two mandatory user-confirmation halts are:
+
+- **End of step-02** — present candidate list, collect inventor info, wait for explicit "write these N points" before entering step-03
+- **End of step-04** — present the engineer-style disclosure draft, wait for user approval before entering step-05
+
+Never skip these halts. They are the safety boundary between analysis (cheap to redo) and document generation (expensive to redo).

package/tools/format-workflow-md.js

@@ -0,0 +1,263 @@
+/**
+ * XiaoMa Workflow Markdown Formatter
+ *
+ * Formats mixed markdown + XML workflow instruction files with:
+ * - 2-space XML indentation
+ * - Preserved markdown content
+ * - Proper tag nesting
+ * - Consistent formatting
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+class WorkflowFormatter {
+  constructor(options = {}) {
+    this.indentSize = options.indentSize || 2;
+    this.preserveMarkdown = options.preserveMarkdown !== false;
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Format a workflow markdown file
+   */
+  format(filePath) {
+    if (this.verbose) {
+      console.log(`Formatting: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const formatted = this.formatContent(content);
+
+    // Only write if content changed
+    if (content === formatted) {
+      if (this.verbose) {
+        console.log(`- No changes: ${filePath}`);
+      }
+      return false;
+    } else {
+      fs.writeFileSync(filePath, formatted, 'utf8');
+      if (this.verbose) {
+        console.log(`✓ Formatted: ${filePath}`);
+      }
+      return true;
+    }
+  }
+
+  /**
+   * Format content string with stateful indentation tracking
+   */
+  formatContent(content) {
+    const lines = content.split('\n');
+    const formatted = [];
+    let indentLevel = 0;
+    let inCodeBlock = false;
+    let checkBlockDepth = 0; // Track nested check blocks
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Track code blocks (don't format inside them)
+      if (trimmed.startsWith('```')) {
+        if (inCodeBlock) {
+          inCodeBlock = false;
+        } else {
+          inCodeBlock = true;
+        }
+        formatted.push(line);
+        continue;
+      }
+
+      // Don't format inside code blocks
+      if (inCodeBlock) {
+        formatted.push(line);
+        continue;
+      }
+
+      // Handle XML tags
+      if (this.isXMLLine(trimmed)) {
+        const result = this.formatXMLLine(trimmed, indentLevel, checkBlockDepth, i, lines);
+        formatted.push(result.line);
+        indentLevel = result.nextIndent;
+        checkBlockDepth = result.nextCheckDepth;
+      } else if (trimmed === '') {
+        // Preserve blank lines
+        formatted.push('');
+      } else {
+        // Markdown content - preserve as-is but maintain current indent if inside XML
+        formatted.push(line);
+      }
+    }
+
+    return formatted.join('\n');
+  }
+
+  /**
+   * Check if line contains XML tag
+   */
+  isXMLLine(line) {
+    return /^<[a-zA-Z-]+(\s|>|\/)/.test(line) || /^<\/[a-zA-Z-]+>/.test(line);
+  }
+
+  /**
+   * Format a single XML line with context awareness
+   */
+  formatXMLLine(line, currentIndent, checkDepth, lineIndex, allLines) {
+    const trimmed = line.trim();
+    let indent = currentIndent;
+    let nextIndent = currentIndent;
+    let nextCheckDepth = checkDepth;
+
+    // Get the tag name
+    const tagMatch = trimmed.match(/^<\/?([a-zA-Z-]+)/);
+    const tagName = tagMatch ? tagMatch[1] : '';
+
+    // Closing tag - decrease indent before this line
+    if (trimmed.startsWith('</')) {
+      indent = Math.max(0, currentIndent - 1);
+      nextIndent = indent;
+
+      // If closing a step, reset check depth
+      if (tagName === 'step' || tagName === 'workflow') {
+        nextCheckDepth = 0;
+      }
+    }
+    // Self-closing tags (opens and closes on same line)
+    // EXCEPT <check> tags which create logical blocks
+    else if (this.isSelfClosingTag(trimmed) && tagName !== 'check') {
+      // These don't change indent level
+      indent = currentIndent;
+      nextIndent = currentIndent;
+    }
+    // Opening tags
+    else if (trimmed.startsWith('<')) {
+      // Check if this is a <check> tag - these create logical blocks
+      if (tagName === 'check') {
+        indent = currentIndent;
+        // Check tags increase indent for following content
+        nextIndent = currentIndent + 1;
+        nextCheckDepth = checkDepth + 1;
+      }
+      // <action> tags inside check blocks stay at current indent
+      else if (tagName === 'action' && checkDepth > 0) {
+        indent = currentIndent;
+        nextIndent = currentIndent; // Don't increase further
+      }
+      // Other tags close check blocks and return to structural level
+      else if (checkDepth > 0) {
+        // Close all check blocks - return to base structural level
+        indent = Math.max(0, currentIndent - checkDepth);
+        nextIndent = indent + 1;
+        nextCheckDepth = 0;
+      }
+      // Regular opening tags (no check blocks active)
+      else {
+        indent = currentIndent;
+        nextIndent = currentIndent + 1;
+      }
+    }
+
+    const indentStr = ' '.repeat(indent * this.indentSize);
+    return {
+      line: indentStr + trimmed,
+      nextIndent: nextIndent,
+      nextCheckDepth: nextCheckDepth,
+    };
+  }
+
+  /**
+   * Check if tag opens and closes on same line
+   */
+  isSelfClosingTag(line) {
+    // Self-closing with />
+    if (line.endsWith('/>')) {
+      return true;
+    }
+    // Opens and closes on same line: <tag>content</tag>
+    const match = line.match(/^<([a-zA-Z-]+)(\s[^>]*)?>.*<\/\1>$/);
+    return match !== null;
+  }
+
+  /**
+   * Check if tag is a block-level structural tag
+   */
+  isBlockLevelTag(tagName) {
+    return ['step', 'workflow', 'check'].includes(tagName);
+  }
+}
+
+/**
+ * CLI Entry Point
+ */
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
+    console.log(`
+XiaoMa Workflow Markdown Formatter
+
+Usage:
+  node format-workflow-md.js <file-pattern> [options]
+
+Options:
+  --verbose, -v     Verbose output
+  --check, -c       Check formatting without writing (exit 1 if changes needed)
+  --help, -h        Show this help
+
+Examples:
+  node format-workflow-md.js src/**/instructions.md
+  node format-workflow-md.js "src/modules/bmb/**/*.md" --verbose
+  node format-workflow-md.js file.md --check
+`);
+    process.exit(0);
+  }
+
+  const verbose = args.includes('--verbose') || args.includes('-v');
+  const check = args.includes('--check') || args.includes('-c');
+
+  // Remove flags from args
+  const files = args.filter((arg) => !arg.startsWith('-'));
+
+  const formatter = new WorkflowFormatter({ verbose });
+  let hasChanges = false;
+  let formattedCount = 0;
+
+  // Process files
+  for (const pattern of files) {
+    // For now, treat as direct file path
+    // TODO: Add glob support for patterns
+    if (fs.existsSync(pattern)) {
+      const stat = fs.statSync(pattern);
+      if (stat.isFile()) {
+        const changed = formatter.format(pattern);
+        if (changed) {
+          hasChanges = true;
+          formattedCount++;
+        }
+      } else if (stat.isDirectory()) {
+        console.error(`Error: ${pattern} is a directory. Please specify file paths.`);
+      }
+    } else {
+      console.error(`Error: File not found: ${pattern}`);
+    }
+  }
+
+  if (verbose || formattedCount > 0) {
+    console.log(`\nFormatted ${formattedCount} file(s)`);
+  }
+
+  if (check && hasChanges) {
+    console.error('\n❌ Some files need formatting. Run without --check to format.');
+    process.exit(1);
+  }
+
+  process.exit(0);
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { WorkflowFormatter };

package/tools/{cli → installer}/README.md

@@ -4,11 +4,11 @@
 
 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 zqyl-xiaoma.
 
 ## 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 @zeyue0329/xiaoma-cli install`. Notes are defined in the module's own `module.yaml` — no changes to the installer are needed.
 
 ### Simple Format
 

package/tools/installer/cli-utils.js

@@ -0,0 +1,57 @@
+const path = require('node:path');
+const prompts = require('./prompts');
+
+const CLIUtils = {
+  /**
+   * Get version from the repo's package.json (tools/installer/ -> repo root is ../../)
+   */
+  getVersion() {
+    try {
+      const packageJson = require(path.join(__dirname, '..', '..', 'package.json'));
+      return packageJson.version || 'Unknown';
+    } catch {
+      return 'Unknown';
+    }
+  },
+
+  /**
+   * Display XiaoMa logo and version using @clack intro + box
+   */
+  async displayLogo() {
+    const version = this.getVersion();
+    const color = await prompts.getColor();
+
+    // XIAOMA block-letter ASCII art (yellow)
+    const logo = [
+      '  ██╗  ██╗██╗ █████╗  ██████╗ ███╗   ███╗ █████╗',
+      '  ╚██╗██╔╝██║██╔══██╗██╔═══██╗████╗ ████║██╔══██╗',
+      '   ╚███╔╝ ██║███████║██║   ██║██╔████╔██║███████║',
+      '   ██╔██╗ ██║██╔══██║██║   ██║██║╚██╔╝██║██╔══██║',
+      '  ██╔╝ ██╗██║██║  ██║╚██████╔╝██║ ╚═╝ ██║██║  ██║',
+      '  ╚═╝  ╚═╝╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝╚═╝  ╚═╝',
+    ]
+      .map((line) => color.yellow(line))
+      .join('\n');
+
+    const tagline = '      AI-Driven Agile Development';
+
+    await prompts.box(`${logo}\n${tagline}`, `v${version}`, {
+      contentAlign: 'center',
+      rounded: true,
+      formatBorder: color.blue,
+    });
+  },
+
+  /**
+   * Display module configuration header
+   * @param {string} moduleName - Module name (fallback if no custom header)
+   * @param {string} header - Custom header from module.yaml
+   * @param {string} subheader - Custom subheader from module.yaml
+   */
+  async displayModuleConfigHeader(moduleName, header = null, subheader = null) {
+    const title = header || `Configuring ${moduleName.toUpperCase()} Module`;
+    await prompts.note(subheader || '', title);
+  },
+};
+
+module.exports = { CLIUtils };