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

package/tools/cli/lib/xml-handler.js

@@ -0,0 +1,229 @@
+const xml2js = require('xml2js');
+const fs = require('fs-extra');
+const path = require('node:path');
+const { getProjectRoot, getSourcePath } = require('./project-root');
+const { YamlXmlBuilder } = require('./yaml-xml-builder');
+
+/**
+ * XML utility functions for XIAOMA installer
+ * Now supports both legacy XML agents and new YAML-based agents
+ */
+class XmlHandler {
+  constructor() {
+    this.parser = new xml2js.Parser({
+      preserveChildrenOrder: true,
+      explicitChildren: true,
+      explicitArray: false,
+      trim: false,
+      normalizeTags: false,
+      attrkey: '$',
+      charkey: '_',
+    });
+
+    this.builder = new xml2js.Builder({
+      renderOpts: {
+        pretty: true,
+        indent: '  ',
+        newline: '\n',
+      },
+      xmldec: {
+        version: '1.0',
+        encoding: 'utf8',
+        standalone: false,
+      },
+      headless: true, // Don't add XML declaration
+      attrkey: '$',
+      charkey: '_',
+    });
+
+    this.yamlBuilder = new YamlXmlBuilder();
+  }
+
+  /**
+   * Load and parse the activation template
+   * @returns {Object} Parsed activation block
+   */
+  async loadActivationTemplate() {
+    const templatePath = getSourcePath('utility', 'models', 'agent-activation-ide.xml');
+
+    try {
+      const xmlContent = await fs.readFile(templatePath, 'utf8');
+
+      // Parse the XML directly (file is now pure XML)
+      const parsed = await this.parser.parseStringPromise(xmlContent);
+      return parsed.activation;
+    } catch (error) {
+      console.error('Failed to load activation template:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Inject activation block into agent XML content
+   * @param {string} agentContent - The agent file content
+   * @param {Object} metadata - Metadata containing module and name
+   * @returns {string} Modified content with activation block
+   */
+  async injectActivation(agentContent, metadata = {}) {
+    try {
+      // Check if already has activation
+      if (agentContent.includes('<activation')) {
+        return agentContent;
+      }
+
+      // Extract the XML portion from markdown if needed
+      let xmlContent = agentContent;
+      let beforeXml = '';
+      let afterXml = '';
+
+      const xmlBlockMatch = agentContent.match(/([\s\S]*?)```xml\n([\s\S]*?)\n```([\s\S]*)/);
+      if (xmlBlockMatch) {
+        beforeXml = xmlBlockMatch[1] + '```xml\n';
+        xmlContent = xmlBlockMatch[2];
+        afterXml = '\n```' + xmlBlockMatch[3];
+      }
+
+      // Parse the agent XML
+      const parsed = await this.parser.parseStringPromise(xmlContent);
+
+      // Get the activation template
+      const activationBlock = await this.loadActivationTemplate();
+      if (!activationBlock) {
+        console.warn('Could not load activation template');
+        return agentContent;
+      }
+
+      // Find the agent node
+      if (
+        parsed.agent && // Insert activation as the first child
+        !parsed.agent.activation
+      ) {
+        // Ensure proper structure
+        if (!parsed.agent.$$) {
+          parsed.agent.$$ = [];
+        }
+
+        // Create the activation node with proper structure
+        const activationNode = {
+          '#name': 'activation',
+          $: { critical: '1' },
+          $$: activationBlock.$$,
+        };
+
+        // Insert at the beginning
+        parsed.agent.$$.unshift(activationNode);
+      }
+
+      // Convert back to XML
+      let modifiedXml = this.builder.buildObject(parsed);
+
+      // Fix indentation - xml2js doesn't maintain our exact formatting
+      // Add 2-space base indentation to match our style
+      const lines = modifiedXml.split('\n');
+      const indentedLines = lines.map((line) => {
+        if (line.trim() === '') return line;
+        if (line.startsWith('<agent')) return line; // Keep agent at column 0
+        return '  ' + line; // Indent everything else
+      });
+      modifiedXml = indentedLines.join('\n');
+
+      // Reconstruct the full content
+      return beforeXml + modifiedXml + afterXml;
+    } catch (error) {
+      console.error('Error injecting activation:', error);
+      return agentContent;
+    }
+  }
+
+  /**
+   * Simple string-based injection (fallback method for legacy XML agents)
+   * This preserves formatting better than XML parsing
+   */
+  injectActivationSimple(agentContent, metadata = {}) {
+    // Check if already has activation
+    if (agentContent.includes('<activation')) {
+      return agentContent;
+    }
+
+    // Load template file
+    const templatePath = getSourcePath('utility', 'models', 'agent-activation-ide.xml');
+
+    try {
+      const templateContent = fs.readFileSync(templatePath, 'utf8');
+
+      // The file is now pure XML, use it directly with proper indentation
+      // Add 2 spaces of indentation for insertion into agent
+      let activationBlock = templateContent
+        .split('\n')
+        .map((line) => (line ? '  ' + line : ''))
+        .join('\n');
+
+      // Replace {agent-filename} with actual filename if metadata provided
+      if (metadata.module && metadata.name) {
+        const agentFilename = `${metadata.module}-${metadata.name}.md`;
+        activationBlock = activationBlock.replace('{agent-filename}', agentFilename);
+      }
+
+      // Find where to insert (after <agent> tag)
+      const agentMatch = agentContent.match(/(<agent[^>]*>)/);
+      if (!agentMatch) {
+        return agentContent;
+      }
+
+      const insertPos = agentMatch.index + agentMatch[0].length;
+
+      // Insert the activation block
+      const before = agentContent.slice(0, insertPos);
+      const after = agentContent.slice(insertPos);
+
+      return before + '\n' + activationBlock + after;
+    } catch (error) {
+      console.error('Error in simple injection:', error);
+      return agentContent;
+    }
+  }
+
+  /**
+   * Build agent from YAML source
+   * @param {string} yamlPath - Path to .agent.yaml file
+   * @param {string} customizePath - Path to .customize.yaml file (optional)
+   * @param {Object} metadata - Build metadata
+   * @returns {string} Generated XML content
+   */
+  async buildFromYaml(yamlPath, customizePath = null, metadata = {}) {
+    try {
+      // Use YamlXmlBuilder to convert YAML to XML
+      const mergedAgent = await this.yamlBuilder.loadAndMergeAgent(yamlPath, customizePath);
+
+      // Build metadata
+      const buildMetadata = {
+        sourceFile: path.basename(yamlPath),
+        sourceHash: await this.yamlBuilder.calculateFileHash(yamlPath),
+        customizeFile: customizePath ? path.basename(customizePath) : null,
+        customizeHash: customizePath ? await this.yamlBuilder.calculateFileHash(customizePath) : null,
+        builderVersion: '1.0.0',
+        includeMetadata: metadata.includeMetadata !== false,
+        forWebBundle: metadata.forWebBundle || false, // Pass through forWebBundle flag
+      };
+
+      // Convert to XML
+      const xml = await this.yamlBuilder.convertToXml(mergedAgent, buildMetadata);
+
+      return xml;
+    } catch (error) {
+      console.error('Error building agent from YAML:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check if a path is a YAML agent file
+   * @param {string} filePath - Path to check
+   * @returns {boolean} True if it's a YAML agent file
+   */
+  isYamlAgent(filePath) {
+    return filePath.endsWith('.agent.yaml');
+  }
+}
+
+module.exports = { XmlHandler };

package/tools/cli/lib/xml-to-markdown.js

@@ -0,0 +1,82 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+function convertXmlToMarkdown(xmlFilePath) {
+  if (!xmlFilePath.endsWith('.xml')) {
+    throw new Error('Input file must be an XML file');
+  }
+
+  const xmlContent = fs.readFileSync(xmlFilePath, 'utf8');
+
+  const basename = path.basename(xmlFilePath, '.xml');
+  const dirname = path.dirname(xmlFilePath);
+  const mdFilePath = path.join(dirname, `${basename}.md`);
+
+  // Extract version and name/title from root element attributes
+  let title = basename;
+  let version = '';
+
+  // Match the root element and its attributes
+  const rootMatch = xmlContent.match(
+    /<[^>\s]+[^>]*?\sv="([^"]+)"[^>]*?(?:\sname="([^"]+)")?|<[^>\s]+[^>]*?(?:\sname="([^"]+)")?[^>]*?\sv="([^"]+)"/,
+  );
+
+  if (rootMatch) {
+    // Handle both v="x" name="y" and name="y" v="x" orders
+    version = rootMatch[1] || rootMatch[4] || '';
+    const nameAttr = rootMatch[2] || rootMatch[3] || '';
+
+    if (nameAttr) {
+      title = nameAttr;
+    } else {
+      // Try to find name in a <name> element if not in attributes
+      const nameElementMatch = xmlContent.match(/<name>([^<]+)<\/name>/);
+      if (nameElementMatch) {
+        title = nameElementMatch[1];
+      }
+    }
+  }
+
+  const heading = version ? `# ${title} v${version}` : `# ${title}`;
+
+  const markdownContent = `${heading}
+
+\`\`\`xml
+${xmlContent}
+\`\`\`
+`;
+
+  fs.writeFileSync(mdFilePath, markdownContent, 'utf8');
+
+  return mdFilePath;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error('Usage: node xml-to-markdown.js <xml-file-path>');
+    process.exit(1);
+  }
+
+  const xmlFilePath = path.resolve(args[0]);
+
+  if (!fs.existsSync(xmlFilePath)) {
+    console.error(`Error: File not found: ${xmlFilePath}`);
+    process.exit(1);
+  }
+
+  try {
+    const mdFilePath = convertXmlToMarkdown(xmlFilePath);
+    console.log(`Successfully converted: ${xmlFilePath} -> ${mdFilePath}`);
+  } catch (error) {
+    console.error(`Error converting file: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { convertXmlToMarkdown };

package/tools/{yaml-format.js → cli/lib/yaml-format.js}

@@ -1,7 +1,7 @@
-const fs = require("node:fs");
-const path = require("node:path");
-const yaml = require("js-yaml");
-const { execSync } = require("node:child_process");
+const fs = require('node:fs');
+const path = require('node:path');
+const yaml = require('js-yaml');
+const { execSync } = require('node:child_process');
 
 // Dynamic import for ES module
 let chalk;
@@ -9,12 +9,12 @@ let chalk;
 // Initialize ES modules
 async function initializeModules() {
   if (!chalk) {
-    chalk = (await import("chalk")).default;
+    chalk = (await import('chalk')).default;
   }
 }
 
 /**
- * YAML Formatter and Linter for XiaoMa-Cli
+ * YAML Formatter and Linter for XiaoMa-Method
  * Formats and validates YAML files and YAML embedded in Markdown
  */
 
@@ -24,12 +24,12 @@ async function formatYamlContent(content, filename) {
     // First try to fix common YAML issues
     let fixedContent = content
       // Fix "commands :" -> "commands:"
-      .replaceAll(/^(\s*)(\w+)\s+:/gm, "$1$2:")
+      .replaceAll(/^(\s*)(\w+)\s+:/gm, '$1$2:')
       // Fix inconsistent list indentation
-      .replaceAll(/^(\s*)-\s{3,}/gm, "$1- ");
+      .replaceAll(/^(\s*)-\s{3,}/gm, '$1- ');
 
     // Skip auto-fixing for .roomodes files - they have special nested structure
-    if (!filename.includes(".roomodes")) {
+    if (!filename.includes('.roomodes')) {
       fixedContent = fixedContent
         // Fix unquoted list items that contain special characters or multiple parts
         .replaceAll(/^(\s*)-\s+(.*)$/gm, (match, indent, content) => {
@@ -40,16 +40,11 @@ async function formatYamlContent(content, filename) {
           // If the content contains special YAML characters or looks complex, quote it
           // BUT skip if it looks like a proper YAML key-value pair (like "key: value")
           if (
-            (content.includes(":") ||
-              content.includes("-") ||
-              content.includes("{") ||
-              content.includes("}")) &&
+            (content.includes(':') || content.includes('-') || content.includes('{') || content.includes('}')) &&
             !/^\w+:\s/.test(content)
           ) {
             // Remove any existing quotes first, escape internal quotes, then add proper quotes
-            const cleanContent = content
-              .replaceAll(/^["']|["']$/g, "")
-              .replaceAll('"', String.raw`\"`);
+            const cleanContent = content.replaceAll(/^["']|["']$/g, '').replaceAll('"', String.raw`\"`);
             return `${indent}- "${cleanContent}"`;
           }
           return match;
@@ -69,36 +64,27 @@ async function formatYamlContent(content, filename) {
       noRefs: true,
       sortKeys: false, // Preserve key order
     });
-    return formatted;
+    // Ensure POSIX-compliant final newline
+    return formatted.endsWith('\n') ? formatted : formatted + '\n';
   } catch (error) {
-    console.error(
-      chalk.red(`❌ YAML syntax error in ${filename}:`),
-      error.message,
-    );
-    console.error(
-      chalk.yellow(`💡 Try manually fixing the YAML structure first`),
-    );
+    console.error(chalk.red(`❌ YAML syntax error in ${filename}:`), error.message);
+    console.error(chalk.yellow(`💡 Try manually fixing the YAML structure first`));
     return null;
   }
 }
 
 async function processMarkdownFile(filePath) {
   await initializeModules();
-  const content = fs.readFileSync(filePath, "utf8");
+  const content = fs.readFileSync(filePath, 'utf8');
   let modified = false;
   let newContent = content;
 
   // Fix untyped code blocks by adding 'text' type
   // Match ``` at start of line followed by newline, but only if it's an opening fence
-  newContent = newContent.replaceAll(
-    /^```\n([\s\S]*?)\n```$/gm,
-    "```text\n$1\n```",
-  );
+  newContent = newContent.replaceAll(/^```\n([\s\S]*?)\n```$/gm, '```text\n$1\n```');
   if (newContent !== content) {
     modified = true;
-    console.log(
-      chalk.blue(`🔧 Added 'text' type to untyped code blocks in ${filePath}`),
-    );
+    console.log(chalk.blue(`🔧 Added 'text' type to untyped code blocks in ${filePath}`));
   }
 
   // Find YAML code blocks
@@ -111,7 +97,7 @@ async function processMarkdownFile(filePath) {
     const formatted = await formatYamlContent(yamlContent, filePath);
     if (formatted !== null) {
       // Remove trailing newline that js-yaml adds
-      const trimmedFormatted = formatted.replace(/\n$/, "");
+      const trimmedFormatted = formatted.replace(/\n$/, '');
 
       if (trimmedFormatted !== yamlContent) {
         modified = true;
@@ -129,8 +115,7 @@ async function processMarkdownFile(filePath) {
   // Apply replacements in reverse order to maintain indices
   for (let index = replacements.length - 1; index >= 0; index--) {
     const { start, end, replacement } = replacements[index];
-    newContent =
-      newContent.slice(0, start) + replacement + newContent.slice(end);
+    newContent = newContent.slice(0, start) + replacement + newContent.slice(end);
   }
 
   if (modified) {
@@ -142,7 +127,7 @@ async function processMarkdownFile(filePath) {
 
 async function processYamlFile(filePath) {
   await initializeModules();
-  const content = fs.readFileSync(filePath, "utf8");
+  const content = fs.readFileSync(filePath, 'utf8');
   const formatted = await formatYamlContent(content, filePath);
 
   if (formatted === null) {
@@ -160,7 +145,7 @@ async function lintYamlFile(filePath) {
   await initializeModules();
   try {
     // Use yaml-lint for additional validation
-    execSync(`npx yaml-lint "${filePath}"`, { stdio: "pipe" });
+    execSync(`npx yaml-lint "${filePath}"`, { stdio: 'pipe' });
     return true;
   } catch (error) {
     console.error(chalk.red(`❌ YAML lint error in ${filePath}:`));
@@ -172,10 +157,10 @@ async function lintYamlFile(filePath) {
 async function main() {
   await initializeModules();
   const arguments_ = process.argv.slice(2);
-  const glob = require("glob");
+  const glob = require('glob');
 
   if (arguments_.length === 0) {
-    console.error("Usage: node yaml-format.js <file1> [file2] ...");
+    console.error('Usage: node yaml-format.js <file1> [file2] ...');
     process.exit(1);
   }
 
@@ -186,7 +171,7 @@ async function main() {
   // Expand glob patterns and collect all files
   const allFiles = [];
   for (const argument of arguments_) {
-    if (argument.includes("*")) {
+    if (argument.includes('*')) {
       // It's a glob pattern
       const matches = glob.sync(argument);
       allFiles.push(...matches);
@@ -199,11 +184,7 @@ async function main() {
   for (const filePath of allFiles) {
     if (!fs.existsSync(filePath)) {
       // Skip silently for glob patterns that don't match anything
-      if (
-        !arguments_.some(
-          (argument) => argument.includes("*") && filePath === argument,
-        )
-      ) {
+      if (!arguments_.some((argument) => argument.includes('*') && filePath === argument)) {
         console.error(chalk.red(`❌ File not found: ${filePath}`));
         hasErrors = true;
       }
@@ -215,14 +196,14 @@ async function main() {
 
     try {
       let changed = false;
-      if (extension === ".md") {
+      if (extension === '.md') {
         changed = await processMarkdownFile(filePath);
       } else if (
-        extension === ".yaml" ||
-        extension === ".yml" ||
-        basename.includes("roomodes") ||
-        basename.includes(".yaml") ||
-        basename.includes(".yml")
+        extension === '.yaml' ||
+        extension === '.yml' ||
+        basename.includes('roomodes') ||
+        basename.includes('.yaml') ||
+        basename.includes('.yml')
       ) {
         // Handle YAML files and special cases like .roomodes
         changed = await processYamlFile(filePath);
@@ -240,36 +221,25 @@ async function main() {
         filesProcessed.push(filePath);
       }
     } catch (error) {
-      console.error(
-        chalk.red(`❌ Error processing ${filePath}:`),
-        error.message,
-      );
+      console.error(chalk.red(`❌ Error processing ${filePath}:`), error.message);
       hasErrors = true;
     }
   }
 
   if (hasChanges) {
-    console.log(
-      chalk.green(
-        `\n✨ YAML formatting completed! Modified ${filesProcessed.length} files:`,
-      ),
-    );
+    console.log(chalk.green(`\n✨ YAML formatting completed! Modified ${filesProcessed.length} files:`));
     for (const file of filesProcessed) console.log(chalk.blue(`  📝 ${file}`));
   }
 
   if (hasErrors) {
-    console.error(
-      chalk.red(
-        "\n💥 Some files had errors. Please fix them before committing.",
-      ),
-    );
+    console.error(chalk.red('\n💥 Some files had errors. Please fix them before committing.'));
     process.exit(1);
   }
 }
 
 if (require.main === module) {
   main().catch((error) => {
-    console.error("Error:", error);
+    console.error('Error:', error);
     process.exit(1);
   });
 }