npm - @zeyue0329/xiaoma-cli - Versions diffs - 1.6.5 → 1.7.0 - Mend

@zeyue0329/xiaoma-cli 1.6.5 → 1.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (950) hide show

package/tools/cli/bundlers/bundlers/web-bundler.js DELETED Viewed

@@ -1,1754 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const chalk = require('chalk');
-const yaml = require('js-yaml');
-const { DependencyResolver } = require('../installers/lib/core/dependency-resolver');
-const { XmlHandler } = require('../lib/xml-handler');
-const { YamlXmlBuilder } = require('../lib/yaml-xml-builder');
-const { AgentPartyGenerator } = require('../lib/agent-party-generator');
-const xml2js = require('xml2js');
-const { getProjectRoot, getSourcePath, getModulePath } = require('../lib/project-root');
-class WebBundler {
-  constructor(sourceDir = null, outputDir = 'web-bundles') {
-    this.sourceDir = sourceDir || getSourcePath();
-    this.outputDir = path.isAbsolute(outputDir) ? outputDir : path.join(getProjectRoot(), outputDir);
-    this.utilityPath = getSourcePath('utility');
-    this.dependencyResolver = new DependencyResolver();
-    this.xmlHandler = new XmlHandler();
-    this.yamlBuilder = new YamlXmlBuilder();
-    // Cache for resolved dependencies to avoid duplicates
-    this.dependencyCache = new Map();
-    // Discovered agents and teams for manifest generation
-    this.discoveredAgents = [];
-    this.discoveredTeams = [];
-    // Temporary directory for generated manifests
-    this.tempDir = path.join(process.cwd(), '.bundler-temp');
-    this.tempManifestDir = path.join(this.tempDir, 'xiaoma', '_cfg');
-    // Bundle statistics
-    this.stats = {
-      totalAgents: 0,
-      bundledAgents: 0,
-      skippedAgents: 0,
-      failedAgents: 0,
-      invalidXml: 0,
-      warnings: [],
-    };
-  }
-  /**
-   * Main entry point to bundle all modules
-   */
-  async bundleAll() {
-    console.log(chalk.cyan.bold('═══════════════════════════════════════════════'));
-    console.log(chalk.cyan.bold('         🚀 Web Bundle Generation'));
-    console.log(chalk.cyan.bold('═══════════════════════════════════════════════\n'));
-    try {
-      // Vendor cross-module workflows FIRST
-      const modules = await this.discoverModules();
-      for (const module of modules) {
-        await this.vendorCrossModuleWorkflows(module);
-      }
-      // Pre-discover all modules to generate complete manifests
-      for (const module of modules) {
-        await this.preDiscoverModule(module);
-      }
-      // Create temporary manifest files
-      await this.createTempManifests();
-      // Process all modules
-      for (const module of modules) {
-        await this.bundleModule(module);
-      }
-      // Display summary
-      this.displaySummary();
-    } finally {
-      // Clean up temp files
-      await this.cleanupTempFiles();
-    }
-  }
-  /**
-   * Bundle a specific module
-   */
-  async bundleModule(moduleName) {
-    const modulePath = getModulePath(moduleName);
-    if (!(await fs.pathExists(modulePath))) {
-      console.log(chalk.yellow(`Module ${moduleName} not found`));
-      return { module: moduleName, agents: [], teams: [] };
-    }
-    console.log(chalk.bold(`\n📦 Bundling module: ${moduleName}`));
-    const results = {
-      module: moduleName,
-      agents: [],
-      teams: [],
-    };
-    // Vendor cross-module workflows first (if not already done by bundleAll)
-    await this.vendorCrossModuleWorkflows(moduleName);
-    // Pre-discover all agents and teams for manifest generation
-    await this.preDiscoverModule(moduleName);
-    // Ensure temp manifests exist (might not exist if called directly)
-    if (!(await fs.pathExists(this.tempManifestDir))) {
-      await this.createTempManifests();
-    }
-    // Process agents
-    const agents = await this.discoverAgents(modulePath);
-    for (const agent of agents) {
-      try {
-        await this.bundleAgent(moduleName, agent, false); // false = don't track again
-        results.agents.push(agent);
-      } catch (error) {
-        console.error(`    Failed to bundle agent ${agent}:`, error.message);
-      }
-    }
-    // Process teams
-    const teams = await this.discoverTeams(modulePath);
-    for (const team of teams) {
-      try {
-        await this.bundleTeam(moduleName, team);
-        results.teams.push(team);
-      } catch (error) {
-        console.error(`    Failed to bundle team ${team}:`, error.message);
-      }
-    }
-    return results;
-  }
-  /**
-   * Bundle a single agent
-   */
-  async bundleAgent(moduleName, agentFile, shouldTrack = true) {
-    const agentName = agentFile.endsWith('.agent.yaml') ? path.basename(agentFile, '.agent.yaml') : path.basename(agentFile, '.md');
-    this.stats.totalAgents++;
-    console.log(chalk.dim(`  → Processing: ${agentName}`));
-    // Vendor cross-module workflows first (if not already done)
-    await this.vendorCrossModuleWorkflows(moduleName);
-    const agentPath = path.join(getModulePath(moduleName), 'agents', agentFile);
-    // Check if agent file exists
-    if (!(await fs.pathExists(agentPath))) {
-      this.stats.failedAgents++;
-      console.log(chalk.red(`    ✗ Agent file not found`));
-      throw new Error(`Agent file not found: ${agentPath}`);
-    }
-    let content;
-    let agentXml;
-    // Handle YAML agents - build in-memory to XML
-    if (agentFile.endsWith('.agent.yaml')) {
-      // Check for webskip flag in YAML before building
-      const yamlContent = await fs.readFile(agentPath, 'utf8');
-      const agentYaml = yaml.load(yamlContent);
-      if (agentYaml?.agent?.webskip === true) {
-        this.stats.skippedAgents++;
-        console.log(chalk.gray(`    ⊘ Skipped (webskip="true")`));
-        return;
-      }
-      // Build agent from YAML (no customize file for web bundles)
-      const xmlContent = await this.yamlBuilder.buildFromYaml(agentPath, null, {
-        includeMetadata: false, // Don't include build metadata in web bundles
-        forWebBundle: true, // Use web-specific activation fragments
-      });
-      content = xmlContent;
-      agentXml = this.extractAgentXml(xmlContent);
-    } else {
-      // Legacy MD format - read and extract XML
-      content = await fs.readFile(agentPath, 'utf8');
-      agentXml = this.extractAgentXml(content);
-    }
-    if (!agentXml) {
-      this.stats.failedAgents++;
-      console.log(chalk.red(`    ✗ No agent XML found in ${agentFile}`));
-      return;
-    }
-    // Check if agent has bundle="false" attribute
-    if (this.shouldSkipBundling(agentXml)) {
-      this.stats.skippedAgents++;
-      console.log(chalk.gray(`    ⊘ Skipped (bundle="false")`));
-      return;
-    }
-    // Process {project-root} references in agent XML
-    agentXml = this.processProjectRootReferences(agentXml);
-    // Track for manifest generation BEFORE generating manifests (if not pre-discovered)
-    if (shouldTrack) {
-      const agentDetails = AgentPartyGenerator.extractAgentDetails(content, moduleName, agentName);
-      if (agentDetails) {
-        this.discoveredAgents.push(agentDetails);
-      }
-    }
-    // Resolve dependencies with warning tracking
-    const dependencyWarnings = [];
-    const { dependencies, skippedWorkflows } = await this.resolveAgentDependencies(agentXml, moduleName, dependencyWarnings);
-    if (dependencyWarnings.length > 0) {
-      this.stats.warnings.push({ agent: agentName, warnings: dependencyWarnings });
-    }
-    // Check for module's default-party.csv and include it as agent manifest
-    const defaultPartyPath = path.join(getModulePath(moduleName), 'teams', 'default-party.csv');
-    if (await fs.pathExists(defaultPartyPath)) {
-      const partyContent = await fs.readFile(defaultPartyPath, 'utf8');
-      // Process any placeholders in the CSV content
-      const processedPartyContent = this.processProjectRootReferences(partyContent);
-      // Wrap as text to preserve raw CSV format in CDATA
-      const wrappedParty = this.wrapContentInXml(processedPartyContent, 'xiaoma/_cfg/agent-manifest.csv', 'text');
-      dependencies.set('xiaoma/_cfg/agent-manifest.csv', wrappedParty);
-      console.log(chalk.gray(`    + Added party manifest from module default-party.csv`));
-    }
-    // Remove commands for skipped workflows from agent XML
-    if (skippedWorkflows.length > 0) {
-      agentXml = this.removeSkippedWorkflowCommands(agentXml, skippedWorkflows);
-    }
-    // Build the bundle (no manifests for individual agents)
-    const bundle = this.buildAgentBundle(agentXml, dependencies);
-    // Validate XML
-    const isValid = await this.validateXml(bundle);
-    if (!isValid) {
-      this.stats.invalidXml++;
-      console.log(chalk.red(`    ⚠ Invalid XML generated!`));
-    }
-    // Format XML for readability
-    const formattedBundle = this.formatXml(bundle);
-    // Write bundle to output
-    const outputPath = path.join(this.outputDir, moduleName, 'agents', `${agentName}.xml`);
-    await fs.ensureDir(path.dirname(outputPath));
-    await fs.writeFile(outputPath, formattedBundle, 'utf8');
-    this.stats.bundledAgents++;
-    const statusIcon = isValid ? chalk.green('✓') : chalk.yellow('⚠');
-    console.log(`    ${statusIcon} Bundled: ${agentName}.xml${isValid ? '' : chalk.yellow(' (invalid XML)')}`);
-  }
-  /**
-   * Bundle a team - includes orchestrator and all agents with their dependencies
-   */
-  async bundleTeam(moduleName, teamFile) {
-    const teamName = path.basename(teamFile, path.extname(teamFile));
-    console.log(chalk.dim(`  → Processing team: ${teamName}`));
-    const teamPath = path.join(getModulePath(moduleName), 'teams', teamFile);
-    // Check if team file exists
-    if (!(await fs.pathExists(teamPath))) {
-      console.log(chalk.red(`    ✗ Team file not found`));
-      throw new Error(`Team file not found: ${teamPath}`);
-    }
-    // Read and parse team YAML
-    const teamContent = await fs.readFile(teamPath, 'utf8');
-    const teamConfig = yaml.load(teamContent);
-    if (!teamConfig || !teamConfig.bundle) {
-      console.log(chalk.red(`    ✗ Invalid team configuration`));
-      return;
-    }
-    // Start building the team bundle
-    const dependencies = new Map();
-    const processed = new Set();
-    const allAgentXmls = [];
-    const warnings = [];
-    // Check if team has a party CSV file (agent manifest)
-    const hasPartyFile = teamConfig.party && teamConfig.party.endsWith('.csv');
-    if (hasPartyFile) {
-      // Load the party CSV and add it as xiaoma/_cfg/agent-manifest.csv
-      const partyPath = path.join(path.dirname(teamPath), teamConfig.party.replace(/^\.\//, ''));
-      if (await fs.pathExists(partyPath)) {
-        const partyContent = await fs.readFile(partyPath, 'utf8');
-        // Process any placeholders in the CSV content
-        const processedPartyContent = this.processProjectRootReferences(partyContent);
-        // Wrap as text/csv to preserve raw CSV format in CDATA
-        const wrappedParty = this.wrapContentInXml(processedPartyContent, 'xiaoma/_cfg/agent-manifest.csv', 'text');
-        dependencies.set('xiaoma/_cfg/agent-manifest.csv', wrappedParty);
-        console.log(chalk.gray(`    + Added agent manifest from: ${teamConfig.party}`));
-      } else {
-        console.log(chalk.yellow(`    ⚠ Party file not found: ${partyPath}`));
-      }
-    }
-    // 1. First, always add the xiaoma-web-orchestrator (XML file only, no transformation needed)
-    const orchestratorXmlPath = path.join(this.sourceDir, 'core', 'agents', 'xiaoma-web-orchestrator.agent.xml');
-    if (await fs.pathExists(orchestratorXmlPath)) {
-      // Read the XML file directly - no transformation needed
-      const xmlContent = await fs.readFile(orchestratorXmlPath, 'utf8');
-      let orchestratorXml = xmlContent.trim();
-      // Process {project-root} references
-      orchestratorXml = this.processProjectRootReferences(orchestratorXml);
-      // Inject help/exit menu items only (orchestrator has its own activation)
-      orchestratorXml = this.injectHelpExitMenuItems(orchestratorXml);
-      // Resolve orchestrator dependencies
-      const { dependencies: orchDeps } = await this.resolveAgentDependencies(orchestratorXml, 'core', warnings);
-      // Merge orchestrator dependencies
-      for (const [id, content] of orchDeps) {
-        if (!dependencies.has(id)) {
-          dependencies.set(id, content);
-        }
-      }
-      // Add orchestrator XML first
-      allAgentXmls.push(orchestratorXml);
-      console.log(chalk.gray(`    + Added orchestrator: xiaoma-web-orchestrator`));
-    } else {
-      console.log(chalk.yellow(`    ⚠ Orchestrator not found at: ${orchestratorXmlPath}`));
-    }
-    // 2. Determine which agents to include
-    let agentsToBundle = [];
-    if (teamConfig.agents === '*' || (Array.isArray(teamConfig.agents) && teamConfig.agents.includes('*'))) {
-      // Include all agents from the module
-      const agentsPath = path.join(getModulePath(moduleName), 'agents');
-      if (await fs.pathExists(agentsPath)) {
-        const agentFiles = await fs.readdir(agentsPath);
-        agentsToBundle = agentFiles
-          .filter((file) => file.endsWith('.agent.yaml') || (file.endsWith('.md') && !file.toLowerCase().includes('readme')))
-          .map((file) => file.replace(/\.(agent\.yaml|md)$/, ''));
-      }
-    } else if (Array.isArray(teamConfig.agents)) {
-      // Include specific agents listed
-      agentsToBundle = teamConfig.agents;
-    } else {
-      console.log(chalk.yellow(`    ⚠ No agents specified in team configuration`));
-    }
-    // 3. Process each agent and their dependencies
-    for (const agentName of agentsToBundle) {
-      // Try YAML first, then MD
-      let agentPath = path.join(getModulePath(moduleName), 'agents', `${agentName}.agent.yaml`);
-      let isYaml = await fs.pathExists(agentPath);
-      if (!isYaml) {
-        agentPath = path.join(getModulePath(moduleName), 'agents', `${agentName}.md`);
-        if (!(await fs.pathExists(agentPath))) {
-          console.log(chalk.yellow(`    ⚠ Agent not found: ${agentName}`));
-          continue;
-        }
-      }
-      let agentXml;
-      if (isYaml) {
-        // Check for webskip flag in YAML
-        const yamlContent = await fs.readFile(agentPath, 'utf8');
-        const agentYaml = yaml.load(yamlContent);
-        if (agentYaml?.agent?.webskip === true) {
-          console.log(chalk.gray(`    ⊘ Skipped agent (webskip="true"): ${agentName}`));
-          continue;
-        }
-        // Build YAML agent in-memory - skip activation for team agents (orchestrator handles it)
-        const xmlContent = await this.yamlBuilder.buildFromYaml(agentPath, null, {
-          includeMetadata: false,
-          skipActivation: true, // Skip activation for team agents
-        });
-        agentXml = this.extractAgentXml(xmlContent);
-      } else {
-        // Read legacy MD agent
-        const agentContent = await fs.readFile(agentPath, 'utf8');
-        agentXml = this.extractAgentXml(agentContent);
-      }
-      if (!agentXml) {
-        console.log(chalk.yellow(`    ⚠ No XML found in agent: ${agentName}`));
-        continue;
-      }
-      // Skip agents with bundle="false"
-      if (this.shouldSkipBundling(agentXml)) {
-        console.log(chalk.gray(`    ⊘ Skipped agent (bundle="false"): ${agentName}`));
-        continue;
-      }
-      // Process {project-root} references
-      agentXml = this.processProjectRootReferences(agentXml);
-      // Resolve agent dependencies
-      const agentWarnings = [];
-      const { dependencies: agentDeps, skippedWorkflows } = await this.resolveAgentDependencies(agentXml, moduleName, agentWarnings);
-      if (agentWarnings.length > 0) {
-        warnings.push({ agent: agentName, warnings: agentWarnings });
-      }
-      // Remove commands for skipped workflows from agent XML
-      if (skippedWorkflows.length > 0) {
-        agentXml = this.removeSkippedWorkflowCommands(agentXml, skippedWorkflows);
-      }
-      // Merge agent dependencies (deduplicate)
-      for (const [id, content] of agentDeps) {
-        if (!dependencies.has(id)) {
-          dependencies.set(id, content);
-        }
-      }
-      // Skip web activation injection for team agents - orchestrator handles everything
-      // Only inject help/exit menu items if missing
-      agentXml = this.injectHelpExitMenuItems(agentXml);
-      // Add agent XML to the collection
-      allAgentXmls.push(agentXml);
-      console.log(chalk.gray(`    + Added agent: ${agentName}`));
-    }
-    // 4. Build the team bundle XML
-    const bundle = this.buildTeamBundle(teamConfig.bundle, allAgentXmls, dependencies);
-    // 5. Validate XML
-    const isValid = await this.validateXml(bundle);
-    if (!isValid) {
-      console.log(chalk.red(`    ⚠ Invalid XML generated for team!`));
-    }
-    // Format XML for readability
-    const formattedBundle = this.formatXml(bundle);
-    // 6. Write bundle to output
-    const outputPath = path.join(this.outputDir, moduleName, 'teams', `${teamName}.xml`);
-    await fs.ensureDir(path.dirname(outputPath));
-    await fs.writeFile(outputPath, formattedBundle, 'utf8');
-    const statusIcon = isValid ? chalk.green('✓') : chalk.yellow('⚠');
-    console.log(`    ${statusIcon} Bundled team: ${teamName}.xml${isValid ? '' : chalk.yellow(' (invalid XML)')}`);
-    // Track warnings
-    if (warnings.length > 0) {
-      this.stats.warnings.push(...warnings);
-    }
-  }
-  /**
-   * Build the final team bundle XML
-   */
-  buildTeamBundle(teamMetadata, agentXmls, dependencies) {
-    const parts = ['<?xml version="1.0" encoding="UTF-8"?>', '<team-bundle>', '  <!-- Agent Definitions -->', '  <agents>'];
-    for (const agentXml of agentXmls) {
-      // Indent each agent XML properly (add 4 spaces to each line)
-      const indentedAgent = agentXml
-        .split('\n')
-        .map((line) => '    ' + line)
-        .join('\n');
-      parts.push(indentedAgent);
-    }
-    parts.push('  </agents>');
-    // Add all dependencies
-    if (dependencies && dependencies.size > 0) {
-      parts.push('', '  <!-- Shared Dependencies -->', '  <dependencies>');
-      for (const [id, content] of dependencies) {
-        // All dependencies are now consistently wrapped in <file> elements
-        // Indent properly (add 4 spaces to each line)
-        const indentedContent = content
-          .split('\n')
-          .map((line) => '    ' + line)
-          .join('\n');
-        parts.push(indentedContent);
-      }
-      parts.push('  </dependencies>');
-    }
-    parts.push('</team-bundle>');
-    return parts.join('\n');
-  }
-  /**
-   * Vendor cross-module workflows for a module
-   * Scans source agent YAML files for workflow-install attributes and copies workflows
-   */
-  async vendorCrossModuleWorkflows(moduleName) {
-    const modulePath = getModulePath(moduleName);
-    const agentsPath = path.join(modulePath, 'agents');
-    if (!(await fs.pathExists(agentsPath))) {
-      return;
-    }
-    // Find all agent YAML files
-    const files = await fs.readdir(agentsPath);
-    const yamlFiles = files.filter((f) => f.endsWith('.agent.yaml'));
-    for (const agentFile of yamlFiles) {
-      const agentPath = path.join(agentsPath, agentFile);
-      const agentYaml = yaml.load(await fs.readFile(agentPath, 'utf8'));
-      const menuItems = agentYaml?.agent?.menu || [];
-      const workflowInstallItems = menuItems.filter((item) => item['workflow-install']);
-      for (const item of workflowInstallItems) {
-        const sourceWorkflowPath = item.workflow;
-        const installWorkflowPath = item['workflow-install'];
-        if (!sourceWorkflowPath || !installWorkflowPath) {
-          continue;
-        }
-        // Parse paths to extract module and workflow location
-        // Support both {project-root}/xiaoma/... and {project-root}/{xiaoma_folder}/... patterns
-        const sourceMatch = sourceWorkflowPath.match(/\{project-root\}\/(?:\{xiaoma_folder\}|xiaoma)\/([^/]+)\/workflows\/(.+)/);
-        const installMatch = installWorkflowPath.match(/\{project-root\}\/(?:\{xiaoma_folder\}|xiaoma)\/([^/]+)\/workflows\/(.+)/);
-        if (!sourceMatch || !installMatch) {
-          continue;
-        }
-        const sourceModule = sourceMatch[1];
-        const sourceWorkflowRelPath = sourceMatch[2];
-        const installModule = installMatch[1];
-        const installWorkflowRelPath = installMatch[2];
-        // Build actual filesystem paths
-        const actualSourceWorkflowPath = path.join(getModulePath(sourceModule), 'workflows', sourceWorkflowRelPath);
-        const actualDestWorkflowPath = path.join(getModulePath(installModule), 'workflows', installWorkflowRelPath);
-        // Check if source workflow exists
-        if (!(await fs.pathExists(actualSourceWorkflowPath))) {
-          console.log(chalk.yellow(`    ⚠ Source workflow not found for vendoring: ${sourceWorkflowPath}`));
-          continue;
-        }
-        // Check if destination already exists (skip if already vendored)
-        if (await fs.pathExists(actualDestWorkflowPath)) {
-          continue;
-        }
-        // Get workflow directory (workflow.yaml is in a directory with other files)
-        const sourceWorkflowDir = path.dirname(actualSourceWorkflowPath);
-        const destWorkflowDir = path.dirname(actualDestWorkflowPath);
-        // Copy entire workflow directory
-        await fs.copy(sourceWorkflowDir, destWorkflowDir, { overwrite: false });
-        // Update config_source in the vendored workflow.yaml
-        const workflowYamlPath = actualDestWorkflowPath;
-        if (await fs.pathExists(workflowYamlPath)) {
-          await this.updateWorkflowConfigSource(workflowYamlPath, installModule);
-        }
-        console.log(chalk.dim(`    → Vendored workflow: ${sourceWorkflowRelPath} → ${installModule}/workflows/${installWorkflowRelPath}`));
-      }
-    }
-  }
-  /**
-   * Update config_source in a vendored workflow YAML file
-   */
-  async updateWorkflowConfigSource(workflowYamlPath, newModuleName) {
-    let yamlContent = await fs.readFile(workflowYamlPath, 'utf8');
-    // Replace config_source with new module reference
-    // Support both old format (xiaoma) and new format ({xiaoma_folder})
-    const configSourcePattern = /config_source:\s*["']?\{project-root\}\/(?:\{xiaoma_folder\}|xiaoma)\/[^/]+\/config\.yaml["']?/g;
-    const newConfigSource = `config_source: "{project-root}/{xiaoma_folder}/${newModuleName}/config.yaml"`;
-    const updatedYaml = yamlContent.replaceAll(configSourcePattern, newConfigSource);
-    await fs.writeFile(workflowYamlPath, updatedYaml, 'utf8');
-  }
-  /**
-   * Pre-discover all agents and teams in a module for manifest generation
-   */
-  async preDiscoverModule(moduleName) {
-    const modulePath = getModulePath(moduleName);
-    // Clear any previously discovered agents for this module
-    this.discoveredAgents = this.discoveredAgents.filter((a) => a.module !== moduleName);
-    // Discover agents
-    const agentsPath = path.join(modulePath, 'agents');
-    if (await fs.pathExists(agentsPath)) {
-      const files = await fs.readdir(agentsPath);
-      for (const file of files) {
-        if (file.endsWith('.agent.yaml') || (file.endsWith('.md') && !file.toLowerCase().includes('readme'))) {
-          const agentPath = path.join(agentsPath, file);
-          let content;
-          if (file.endsWith('.agent.yaml')) {
-            // Check for webskip flag in YAML
-            const yamlContent = await fs.readFile(agentPath, 'utf8');
-            const agentYaml = yaml.load(yamlContent);
-            if (agentYaml?.agent?.webskip === true) {
-              continue; // Skip this agent
-            }
-            // Build YAML agent in-memory
-            content = await this.yamlBuilder.buildFromYaml(agentPath, null, {
-              includeMetadata: false,
-            });
-          } else {
-            // Read legacy MD agent
-            content = await fs.readFile(agentPath, 'utf8');
-          }
-          const agentXml = this.extractAgentXml(content);
-          if (agentXml) {
-            // Skip agents with bundle="false"
-            if (this.shouldSkipBundling(agentXml)) {
-              continue;
-            }
-            const agentName = file.endsWith('.agent.yaml') ? path.basename(file, '.agent.yaml') : path.basename(file, '.md');
-            // Use the shared generator to extract agent details (pass full content)
-            const agentDetails = AgentPartyGenerator.extractAgentDetails(content, moduleName, agentName);
-            if (agentDetails) {
-              this.discoveredAgents.push(agentDetails);
-            }
-          }
-        }
-      }
-    }
-    // TODO: Discover teams when implemented
-  }
-  /**
-   * Extract agent XML from markdown content
-   */
-  extractAgentXml(content) {
-    // Try 4 backticks first (can contain 3 backtick blocks inside)
-    let match = content.match(/````xml\s*([\s\S]*?)````/);
-    if (!match) {
-      // Fall back to 3 backticks if no 4-backtick block found
-      match = content.match(/```xml\s*([\s\S]*?)```/);
-    }
-    if (match) {
-      const xmlContent = match[1];
-      const agentMatch = xmlContent.match(/<agent[^>]*>[\s\S]*?<\/agent>/);
-      return agentMatch ? agentMatch[0] : null;
-    }
-    // Fall back to direct extraction
-    match = content.match(/<agent[^>]*>[\s\S]*?<\/agent>/);
-    return match ? match[0] : null;
-  }
-  /**
-   * Resolve all dependencies for an agent
-   */
-  async resolveAgentDependencies(agentXml, moduleName, warnings = []) {
-    const dependencies = new Map();
-    const processed = new Set();
-    const skippedWorkflows = [];
-    // Extract file references from agent XML
-    const { refs, workflowRefs } = this.extractFileReferences(agentXml);
-    // Process regular file references
-    for (const ref of refs) {
-      await this.processFileDependency(ref, dependencies, processed, moduleName, warnings);
-    }
-    // Process workflow references with special handling
-    for (const workflowRef of workflowRefs) {
-      const result = await this.processWorkflowDependency(workflowRef, dependencies, processed, moduleName, warnings);
-      if (result && result.skipped) {
-        skippedWorkflows.push(workflowRef);
-      }
-    }
-    return { dependencies, skippedWorkflows };
-  }
-  /**
-   * Extract file references from agent XML
-   */
-  extractFileReferences(xml) {
-    const refs = new Set();
-    const workflowRefs = new Set();
-    // Remove agent id attribute to prevent it from being treated as a dependency
-    // The id attribute is just a metadata identifier, not a file reference
-    const xmlWithoutAgentId = xml.replace(/<agent[^>]*id="[^"]*"[^>]*>/, (match) => {
-      return match.replace(/\sid="[^"]*"/, '');
-    });
-    // Match various file reference patterns
-    const patterns = [
-      /exec="([^"]+)"/g, // Command exec paths
-      /tmpl="([^"]+)"/g, // Template paths
-      /data="([^"]+)"/g, // Data file paths
-      /file="([^"]+)"/g, // Generic file refs
-      /src="([^"]+)"/g, // Source paths
-      /system-prompts="([^"]+)"/g,
-      /tools="([^"]+)"/g,
-      /knowledge="([^"]+)"/g,
-      /{project-root}\/([^"'\s<>]+)/g, // Legacy {project-root} paths
-      /\bxiaoma\/([^"'\s<>]+)/g, // Direct xiaoma/ paths (after {xiaoma_folder} replacement)
-    ];
-    for (const pattern of patterns) {
-      let match;
-      // Use the XML with agent id removed for pattern matching
-      while ((match = pattern.exec(xmlWithoutAgentId)) !== null) {
-        let filePath = match[1];
-        // Remove {project-root} prefix if present
-        filePath = filePath.replace(/^{project-root}\//, '');
-        // Remove {xiaoma_folder} prefix if present (should be rare, mostly replaced already)
-        filePath = filePath.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-        // For xiaoma/ pattern, prepend 'xiaoma/' since it was captured without it
-        if (pattern.source.includes(String.raw`\bxiaoma\/`)) {
-          filePath = 'xiaoma/' + filePath;
-        }
-        // Skip obvious placeholder/example paths
-        if (filePath && !filePath.includes('path/to/') && !filePath.includes('example') && !filePath.includes('...')) {
-          refs.add(filePath);
-        }
-      }
-    }
-    // Extract workflow references from agent files
-    const workflowPatterns = [
-      /workflow="([^"]+)"/g, // Menu items with workflow attribute
-      /validate-workflow="([^"]+)"/g, // Validation workflow references
-    ];
-    for (const pattern of workflowPatterns) {
-      let match;
-      // Use original xml for workflow patterns (they don't conflict with agent id)
-      while ((match = pattern.exec(xml)) !== null) {
-        let workflowPath = match[1];
-        workflowPath = workflowPath.replace(/^{project-root}\//, '');
-        // Remove {xiaoma_folder} prefix if present and replace with xiaoma
-        workflowPath = workflowPath.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-        // Skip obvious placeholder/example paths
-        if (workflowPath && workflowPath.endsWith('.yaml') && !workflowPath.includes('path/to/') && !workflowPath.includes('example')) {
-          workflowRefs.add(workflowPath);
-        }
-      }
-    }
-    return { refs: [...refs], workflowRefs: [...workflowRefs] };
-  }
-  /**
-   * Remove commands from agent XML that reference skipped workflows
-   */
-  removeSkippedWorkflowCommands(agentXml, skippedWorkflows) {
-    let modifiedXml = agentXml;
-    // For each skipped workflow, find and remove menu items and commands
-    for (const workflowPath of skippedWorkflows) {
-      // Need to escape special regex characters in the path
-      const escapedPath = workflowPath.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-      // Pattern 1: Remove <item> tags with workflow attribute
-      // Match: <item cmd="..." workflow="workflowPath">...</item>
-      const itemWorkflowPattern = new RegExp(`\\s*<item\\s+[^>]*workflow="[^"]*${escapedPath}"[^>]*>.*?</item>\\s*`, 'gs');
-      modifiedXml = modifiedXml.replace(itemWorkflowPattern, '');
-    }
-    return modifiedXml;
-  }
-  /**
-   * Process a file dependency recursively
-   */
-  async processFileDependency(filePath, dependencies, processed, moduleName, warnings = []) {
-    // Skip workflow YAML files - they're handled by processWorkflowDependency
-    if (filePath.includes('/workflow') && filePath.endsWith('workflow.yaml')) {
-      return;
-    }
-    // Skip if already processed
-    if (processed.has(filePath)) {
-      return;
-    }
-    processed.add(filePath);
-    // Skip agent-manifest.csv manifest for web bundles (agents are already bundled)
-    if (filePath === 'xiaoma/_cfg/agent-manifest.csv' || filePath.endsWith('/agent-manifest.csv')) {
-      return;
-    }
-    // Handle wildcard patterns
-    if (filePath.includes('*')) {
-      await this.processWildcardDependency(filePath, dependencies, processed, moduleName, warnings);
-      return;
-    }
-    // Resolve actual file path
-    const actualPath = this.resolveFilePath(filePath, moduleName);
-    if (!actualPath || !(await fs.pathExists(actualPath))) {
-      warnings.push(filePath);
-      return;
-    }
-    // Skip if it's a directory
-    const stats = await fs.stat(actualPath);
-    if (stats.isDirectory()) {
-      // Silently skip directories - they're not file dependencies
-      return;
-    }
-    // Read file content
-    let content = await fs.readFile(actualPath, 'utf8');
-    // Process {project-root} references
-    content = this.processProjectRootReferences(content);
-    // Extract dependencies from frontmatter if present
-    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (frontmatterMatch) {
-      const frontmatter = frontmatterMatch[1];
-      // Look for dependencies in frontmatter
-      const depMatch = frontmatter.match(/dependencies:\s*\[(.*?)\]/);
-      if (depMatch) {
-        const deps = depMatch[1].match(/['"]([^'"]+)['"]/g);
-        if (deps) {
-          for (const dep of deps) {
-            let depPath = dep.replaceAll(/['"]/g, '').replace(/^{project-root}\//, '');
-            depPath = depPath.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-            if (depPath && !processed.has(depPath)) {
-              await this.processFileDependency(depPath, dependencies, processed, moduleName, warnings);
-            }
-          }
-        }
-      }
-      // Look for template references
-      const templateMatch = frontmatter.match(/template:\s*\[(.*?)\]/);
-      if (templateMatch) {
-        const templates = templateMatch[1].match(/['"]([^'"]+)['"]/g);
-        if (templates) {
-          for (const template of templates) {
-            let templatePath = template.replaceAll(/['"]/g, '').replace(/^{project-root}\//, '');
-            templatePath = templatePath.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-            if (templatePath && !processed.has(templatePath)) {
-              await this.processFileDependency(templatePath, dependencies, processed, moduleName, warnings);
-            }
-          }
-        }
-      }
-    }
-    // Extract XML from markdown if applicable
-    const ext = path.extname(actualPath).toLowerCase();
-    let processedContent = content;
-    switch (ext) {
-      case '.md': {
-        // Try to extract XML from markdown - handle both 3 and 4 backtick blocks
-        // First try 4 backticks (which can contain 3 backtick blocks inside)
-        let xmlMatches = [...content.matchAll(/````xml\s*([\s\S]*?)````/g)];
-        // If no 4-backtick blocks, try 3 backticks
-        if (xmlMatches.length === 0) {
-          xmlMatches = [...content.matchAll(/```xml\s*([\s\S]*?)```/g)];
-        }
-        const xmlBlocks = [];
-        for (const match of xmlMatches) {
-          if (match[1]) {
-            xmlBlocks.push(match[1].trim());
-          }
-        }
-        if (xmlBlocks.length > 0) {
-          // For XML content, just include it directly (it's already valid XML)
-          processedContent = xmlBlocks.join('\n\n');
-        } else {
-          // No XML blocks found, skip non-XML markdown files
-          return;
-        }
-        break;
-      }
-      case '.csv': {
-        // CSV files need special handling - convert to XML file-index
-        const lines = content.split('\n').filter((line) => line.trim());
-        if (lines.length === 0) return;
-        const headers = lines[0].split(',').map((h) => h.trim());
-        const rows = lines.slice(1);
-        const indexParts = [`<file-index id="${filePath}">`];
-        indexParts.push('  <items>');
-        // Track files referenced in CSV for additional bundling
-        const referencedFiles = new Set();
-        for (const row of rows) {
-          const values = row.split(',').map((v) => v.trim());
-          if (values.every((v) => !v)) continue;
-          indexParts.push('    <item>');
-          for (const [i, header] of headers.entries()) {
-            const value = values[i] || '';
-            const tagName = header.toLowerCase().replaceAll(/[^a-z0-9]/g, '_');
-            indexParts.push(`      <${tagName}>${value}</${tagName}>`);
-            // Track referenced files
-            if (header.toLowerCase().includes('file') && value.endsWith('.md')) {
-              // Build path relative to CSV location
-              const csvDir = path.dirname(actualPath);
-              const refPath = path.join(csvDir, value);
-              if (fs.existsSync(refPath)) {
-                const refId = filePath.replace('index.csv', value);
-                referencedFiles.add(refId);
-              }
-            }
-          }
-          indexParts.push('    </item>');
-        }
-        indexParts.push('  </items>', '</file-index>');
-        // Store the XML version wrapped in a file element
-        const csvXml = indexParts.join('\n');
-        const wrappedCsv = `<file id="${filePath}" type="xml">\n${csvXml}\n</file>`;
-        dependencies.set(filePath, wrappedCsv);
-        // Process referenced files from CSV
-        for (const refId of referencedFiles) {
-          if (!processed.has(refId)) {
-            await this.processFileDependency(refId, dependencies, processed, moduleName, warnings);
-          }
-        }
-        return;
-      }
-      case '.xml': {
-        // XML files can be included directly
-        processedContent = content;
-        break;
-      }
-      default: {
-        // For other non-XML file types, skip them
-        return;
-      }
-    }
-    // Determine file type for wrapping
-    let fileType = 'text';
-    if (ext === '.xml' || (ext === '.md' && processedContent.trim().startsWith('<'))) {
-      fileType = 'xml';
-    } else
-      switch (ext) {
-        case '.yaml':
-        case '.yml': {
-          fileType = 'yaml';
-          break;
-        }
-        case '.json': {
-          fileType = 'json';
-          break;
-        }
-        case '.md': {
-          fileType = 'md';
-          break;
-        }
-        // No default
-      }
-    // Wrap content in file element and store
-    const wrappedContent = this.wrapContentInXml(processedContent, filePath, fileType);
-    dependencies.set(filePath, wrappedContent);
-    // Recursively scan for more dependencies
-    const { refs: nestedRefs } = this.extractFileReferences(processedContent);
-    for (const ref of nestedRefs) {
-      await this.processFileDependency(ref, dependencies, processed, moduleName, warnings);
-    }
-  }
-  /**
-   * Process a workflow YAML file and its bundle files
-   */
-  async processWorkflowDependency(workflowPath, dependencies, processed, moduleName, warnings = []) {
-    // Skip if already processed
-    if (processed.has(workflowPath)) {
-      return { skipped: false };
-    }
-    processed.add(workflowPath);
-    // Resolve actual file path
-    const actualPath = this.resolveFilePath(workflowPath, moduleName);
-    if (!actualPath || !(await fs.pathExists(actualPath))) {
-      warnings.push(workflowPath);
-      return { skipped: true };
-    }
-    // Read and parse YAML file
-    const yamlContent = await fs.readFile(actualPath, 'utf8');
-    let workflowConfig;
-    try {
-      workflowConfig = yaml.load(yamlContent);
-    } catch (error) {
-      warnings.push(`${workflowPath} (invalid YAML: ${error.message})`);
-      return { skipped: true };
-    }
-    // Check if web_bundle is explicitly set to false
-    if (workflowConfig.web_bundle === false) {
-      // Mark this workflow as skipped so we can remove the command from agent
-      return { skipped: true, workflowPath };
-    }
-    // Create YAML content with only web_bundle section (flattened)
-    let bundleYamlContent;
-    if (workflowConfig.web_bundle && typeof workflowConfig.web_bundle === 'object') {
-      // Only include the web_bundle content, flattened to root level
-      bundleYamlContent = yaml.dump(workflowConfig.web_bundle);
-    } else {
-      // If no web_bundle section, include full YAML
-      bundleYamlContent = yamlContent;
-    }
-    // Process {project-root} and {xiaoma_folder} references in the YAML content
-    bundleYamlContent = this.processProjectRootReferences(bundleYamlContent);
-    // Include the YAML file with only web_bundle content, wrapped in XML
-    // Process the workflow path to create a clean ID
-    let yamlId = workflowPath.replace(/^{project-root}\//, '');
-    yamlId = yamlId.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-    const wrappedYaml = this.wrapContentInXml(bundleYamlContent, yamlId, 'yaml');
-    dependencies.set(yamlId, wrappedYaml);
-    // Always include core workflow task when processing workflows
-    await this.includeCoreWorkflowFiles(dependencies, processed, moduleName, warnings);
-    // Check if advanced elicitation is enabled
-    if (workflowConfig.web_bundle && workflowConfig.web_bundle.use_advanced_elicitation) {
-      await this.includeAdvancedElicitationFiles(dependencies, processed, moduleName, warnings);
-    }
-    // Process web_bundle_files if they exist
-    if (workflowConfig.web_bundle && workflowConfig.web_bundle.web_bundle_files) {
-      const bundleFiles = workflowConfig.web_bundle.web_bundle_files;
-      for (const bundleFilePath of bundleFiles) {
-        // Process the file path to create a clean ID for checking if already processed
-        let cleanFilePath = bundleFilePath.replace(/^{project-root}\//, '');
-        cleanFilePath = cleanFilePath.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-        if (processed.has(cleanFilePath)) {
-          continue;
-        }
-        const bundleActualPath = this.resolveFilePath(bundleFilePath, moduleName);
-        if (!bundleActualPath || !(await fs.pathExists(bundleActualPath))) {
-          // Use the cleaned path in warnings (with {xiaoma_folder} replaced)
-          warnings.push(cleanFilePath);
-          continue;
-        }
-        // Check if this is another workflow.yaml file - if so, recursively process it
-        if (bundleFilePath.endsWith('workflow.yaml')) {
-          // Recursively process this workflow and its dependencies
-          await this.processWorkflowDependency(bundleFilePath, dependencies, processed, moduleName, warnings);
-        } else {
-          // Regular file - process normally
-          processed.add(cleanFilePath);
-          // Read the file content
-          let fileContent = await fs.readFile(bundleActualPath, 'utf8');
-          const fileExt = path.extname(bundleActualPath).toLowerCase().replace('.', '');
-          // Process {project-root} references before wrapping
-          fileContent = this.processProjectRootReferences(fileContent);
-          // Wrap in XML with proper escaping
-          const wrappedContent = this.wrapContentInXml(fileContent, cleanFilePath, fileExt);
-          dependencies.set(cleanFilePath, wrappedContent);
-        }
-      }
-    }
-    return { skipped: false };
-  }
-  /**
-   * Include core workflow task files
-   */
-  async includeCoreWorkflowFiles(dependencies, processed, moduleName, warnings = []) {
-    const coreWorkflowPath = 'xiaoma/core/tasks/workflow.xml';
-    if (processed.has(coreWorkflowPath)) {
-      return;
-    }
-    processed.add(coreWorkflowPath);
-    const actualPath = this.resolveFilePath(coreWorkflowPath, moduleName);
-    if (!actualPath || !(await fs.pathExists(actualPath))) {
-      warnings.push(coreWorkflowPath);
-      return;
-    }
-    let fileContent = await fs.readFile(actualPath, 'utf8');
-    // Process {project-root} and {xiaoma_folder} references
-    fileContent = this.processProjectRootReferences(fileContent);
-    const wrappedContent = this.wrapContentInXml(fileContent, coreWorkflowPath, 'xml');
-    dependencies.set(coreWorkflowPath, wrappedContent);
-  }
-  /**
-   * Include advanced elicitation files
-   */
-  async includeAdvancedElicitationFiles(dependencies, processed, moduleName, warnings = []) {
-    const elicitationFiles = ['xiaoma/core/tasks/advanced-elicitation.xml', 'xiaoma/core/tasks/advanced-elicitation-methods.csv'];
-    for (const filePath of elicitationFiles) {
-      if (processed.has(filePath)) {
-        continue;
-      }
-      processed.add(filePath);
-      const actualPath = this.resolveFilePath(filePath, moduleName);
-      if (!actualPath || !(await fs.pathExists(actualPath))) {
-        warnings.push(filePath);
-        continue;
-      }
-      let fileContent = await fs.readFile(actualPath, 'utf8');
-      // Process {project-root} and {xiaoma_folder} references
-      fileContent = this.processProjectRootReferences(fileContent);
-      const fileExt = path.extname(actualPath).toLowerCase().replace('.', '');
-      const wrappedContent = this.wrapContentInXml(fileContent, filePath, fileExt);
-      dependencies.set(filePath, wrappedContent);
-    }
-  }
-  /**
-   * Wrap file content in XML with proper escaping
-   */
-  wrapContentInXml(content, id, type = 'text') {
-    // For XML files, include directly without CDATA (they're already valid XML)
-    if (type === 'xml') {
-      // XML files can be included directly as they're already well-formed
-      // Just wrap in a file element
-      return `<file id="${id}" type="${type}">\n${content}\n</file>`;
-    }
-    // For all other file types, use CDATA to preserve content exactly
-    // Escape any ]]> sequences in the content by splitting CDATA sections
-    // Replace ]]> with ]]]]><![CDATA[> to properly escape it within CDATA
-    const escapedContent = content.replaceAll(']]>', ']]]]><![CDATA[>');
-    // Use CDATA to preserve content exactly as-is, including special characters
-    return `<file id="${id}" type="${type}"><![CDATA[${escapedContent}]]></file>`;
-  }
-  /**
-   * Process wildcard dependency patterns
-   */
-  async processWildcardDependency(pattern, dependencies, processed, moduleName, warnings = []) {
-    // Remove {project-root} prefix
-    pattern = pattern.replace(/^{project-root}\//, '');
-    // Replace {xiaoma_folder} with xiaoma
-    pattern = pattern.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-    // Get directory and file pattern
-    const lastSlash = pattern.lastIndexOf('/');
-    const dirPath = pattern.slice(0, Math.max(0, lastSlash));
-    const filePattern = pattern.slice(Math.max(0, lastSlash + 1));
-    // Resolve directory path without checking file existence
-    let dir;
-    if (dirPath.startsWith('xiaoma/')) {
-      // Remove xiaoma/ prefix
-      const actualPath = dirPath.replace(/^xiaoma\//, '');
-      // Try different path mappings for directories
-      // Modules are directly under src/, e.g. xiaoma/cis/... -> src/cis/...
-      const possibleDirs = [path.join(this.sourceDir, actualPath)];
-      for (const testDir of possibleDirs) {
-        if (fs.existsSync(testDir)) {
-          dir = testDir;
-          break;
-        }
-      }
-    }
-    if (!dir) {
-      warnings.push(`${pattern} (could not resolve directory)`);
-      return;
-    }
-    if (!(await fs.pathExists(dir))) {
-      warnings.push(pattern);
-      return;
-    }
-    // Read directory and match files
-    const files = await fs.readdir(dir);
-    let matchedFiles = [];
-    if (filePattern === '*.*') {
-      matchedFiles = files;
-    } else if (filePattern.startsWith('*.')) {
-      const ext = filePattern.slice(1);
-      matchedFiles = files.filter((f) => f.endsWith(ext));
-    } else {
-      // Simple glob matching
-      const regex = new RegExp('^' + filePattern.replace('*', '.*') + '$');
-      matchedFiles = files.filter((f) => regex.test(f));
-    }
-    // Process each matched file
-    for (const file of matchedFiles) {
-      const fullPath = dirPath + '/' + file;
-      if (!processed.has(fullPath)) {
-        await this.processFileDependency(fullPath, dependencies, processed, moduleName, warnings);
-      }
-    }
-  }
-  /**
-   * Resolve file path relative to project
-   */
-  resolveFilePath(filePath, moduleName) {
-    // Remove {project-root} prefix
-    filePath = filePath.replace(/^{project-root}\//, '');
-    // Replace {xiaoma_folder} with xiaoma
-    filePath = filePath.replace(/^{xiaoma_folder}\//, 'xiaoma/');
-    filePath = filePath.replace(/^{xiaoma_folder}$/, 'xiaoma');
-    // Check temp directory first for _cfg files
-    if (filePath.startsWith('xiaoma/_cfg/')) {
-      const filename = filePath.split('/').pop();
-      const tempPath = path.join(this.tempManifestDir, filename);
-      if (fs.existsSync(tempPath)) {
-        return tempPath;
-      }
-    }
-    // Handle different path patterns for xiaoma files
-    // xiaoma/cis/tasks/brain-session.md -> src/cis/tasks/brain-session.md
-    // xiaoma/core/tasks/create-doc.md -> src/core/tasks/create-doc.md
-    // xiaoma/xmc/templates/brief.md -> src/xmc/templates/brief.md
-    let actualPath = filePath;
-    if (filePath.startsWith('xiaoma/')) {
-      // Remove xiaoma/ prefix
-      actualPath = filePath.replace(/^xiaoma\//, '');
-      // Check if it's a module-specific file (cis, xmc, etc) or core file
-      const parts = actualPath.split('/');
-      const firstPart = parts[0];
-      // Try different path mappings
-      const possiblePaths = [
-        // Try in temp directory first
-        path.join(this.tempDir, filePath),
-        // Try as direct path: xiaoma/xmc/... -> src/xmc/..., xiaoma/core/... -> src/core/...
-        path.join(this.sourceDir, actualPath),
-        // Try without any prefix in src
-        path.join(this.sourceDir, parts.slice(1).join('/')),
-        // Try in project root
-        path.join(this.sourceDir, '..', actualPath),
-        // Try original with xiaoma
-        path.join(this.sourceDir, '..', filePath),
-      ];
-      for (const testPath of possiblePaths) {
-        if (fs.existsSync(testPath)) {
-          return testPath;
-        }
-      }
-    }
-    // Try standard paths for non-xiaoma files
-    const basePaths = [
-      this.sourceDir, // src directory
-      getModulePath(moduleName), // Current module directly under src/
-      path.join(this.sourceDir, '..'), // Project root
-    ];
-    for (const basePath of basePaths) {
-      const fullPath = path.join(basePath, actualPath);
-      if (fs.existsSync(fullPath)) {
-        return fullPath;
-      }
-    }
-    return null;
-  }
-  /**
-   * Process and remove {project-root} references and replace {xiaoma_folder} with xiaoma
-   */
-  processProjectRootReferences(content) {
-    // Remove {project-root}/ prefix (with slash)
-    content = content.replaceAll('{project-root}/', '');
-    // Also remove {project-root} without slash
-    content = content.replaceAll('{project-root}', '');
-    // Replace {xiaoma_folder} with xiaoma
-    content = content.replaceAll('{xiaoma_folder}', 'xiaoma');
-    return content;
-  }
-  /**
-   * Escape special XML characters in text content
-   */
-  escapeXmlText(text) {
-    return text
-      .replaceAll('&', '&amp;')
-      .replaceAll('<', '&lt;')
-      .replaceAll('>', '&gt;')
-      .replaceAll('"', '&quot;')
-      .replaceAll("'", '&apos;');
-  }
-  /**
-   * Escape XML content while preserving XML tags
-   */
-  escapeXmlContent(content) {
-    const tagPattern = /<([^>]+)>/g;
-    const parts = [];
-    let lastIndex = 0;
-    let match;
-    while ((match = tagPattern.exec(content)) !== null) {
-      if (match.index > lastIndex) {
-        parts.push(this.escapeXmlText(content.slice(lastIndex, match.index)));
-      }
-      parts.push('<' + match[1] + '>');
-      lastIndex = match.index + match[0].length;
-    }
-    if (lastIndex < content.length) {
-      parts.push(this.escapeXmlText(content.slice(lastIndex)));
-    }
-    return parts.join('');
-  }
-  /**
-   * Inject help and exit menu items into agent XML
-   */
-  injectHelpExitMenuItems(agentXml) {
-    // Check if menu already has help and exit
-    const hasHelp = agentXml.includes('cmd="*help"') || agentXml.includes('trigger="*help"');
-    const hasExit = agentXml.includes('cmd="*exit"') || agentXml.includes('trigger="*exit"');
-    if (hasHelp && hasExit) {
-      return agentXml; // Already has both, skip injection
-    }
-    // Find the menu section
-    const menuMatch = agentXml.match(/(<menu>[\s\S]*?<\/menu>)/);
-    if (!menuMatch) {
-      return agentXml; // No menu found, skip injection
-    }
-    const menuContent = menuMatch[1];
-    const menuClosingMatch = menuContent.match(/(\s*)<\/menu>/);
-    if (!menuClosingMatch) {
-      return agentXml;
-    }
-    const indent = menuClosingMatch[1];
-    const menuItems = [];
-    if (!hasHelp) {
-      menuItems.push(`${indent}<item cmd="*menu">[M] Redisplay Menu Options</item>`);
-    }
-    if (!hasExit) {
-      menuItems.push(`${indent}<item cmd="*dismiss">[D] Dismiss Agent</item>`);
-    }
-    if (menuItems.length === 0) {
-      return agentXml;
-    }
-    // Inject menu items before closing </menu> tag
-    const newMenuContent = menuContent.replace(/(\s*)<\/menu>/, `\n${menuItems.join('\n')}\n${indent}</menu>`);
-    return agentXml.replace(menuContent, newMenuContent);
-  }
-  /**
-   * Inject web activation instructions into agent XML
-   */
-  injectWebActivation(agentXml) {
-    // First, always inject help/exit menu items
-    agentXml = this.injectHelpExitMenuItems(agentXml);
-    // Load the web activation template
-    const activationPath = path.join(this.sourceDir, 'utility', 'models', 'agent-activation-web.xml');
-    if (!fs.existsSync(activationPath)) {
-      console.warn(chalk.yellow('Warning: agent-activation-web.xml not found, skipping activation injection'));
-      return agentXml;
-    }
-    const activationXml = fs.readFileSync(activationPath, 'utf8');
-    // For web bundles, ALWAYS replace existing activation with web activation
-    // This is because fragment-based activation assumes filesystem access which won't work in web bundles
-    const hasActivation = agentXml.includes('<activation');
-    if (hasActivation) {
-      // Replace existing activation block with web activation
-      const injectedXml = agentXml.replace(/<activation[^>]*>[\s\S]*?<\/activation>/, activationXml);
-      return injectedXml;
-    }
-    // Check for critical-actions block (legacy)
-    const hasCriticalActions = agentXml.includes('<critical-actions');
-    if (hasCriticalActions) {
-      // Replace critical-actions block with activation
-      const injectedXml = agentXml.replace(/<critical-actions>[\s\S]*?<\/critical-actions>/, activationXml);
-      return injectedXml;
-    }
-    // If no critical-actions, inject before closing </agent> tag
-    const closingTagMatch = agentXml.match(/(\s*)<\/agent>/);
-    if (!closingTagMatch) {
-      console.warn(chalk.yellow('Warning: Could not find </agent> tag for activation injection'));
-      return agentXml;
-    }
-    // Inject the activation block before the closing </agent> tag
-    // Properly indent each line of the activation XML
-    const indent = closingTagMatch[1];
-    const indentedActivation = activationXml
-      .split('\n')
-      .map((line) => (line.trim() ? indent + line : ''))
-      .join('\n');
-    const injectedXml = agentXml.replace(/(\s*)<\/agent>/, `\n${indentedActivation}\n${indent}</agent>`);
-    return injectedXml;
-  }
-  /**
-   * Build the final agent bundle XML
-   */
-  buildAgentBundle(agentXml, dependencies) {
-    // Web activation is now handled by fragments during YAML building
-    // agentXml = this.injectWebActivation(agentXml);
-    const parts = [
-      '<?xml version="1.0" encoding="UTF-8"?>',
-      '<agent-bundle>',
-      '  <!-- Agent Definition -->',
-      '  ' + agentXml.replaceAll('\n', '\n  '),
-    ];
-    // Add dependencies (all are now consistently wrapped in <file> elements)
-    if (dependencies && dependencies.size > 0) {
-      parts.push('\n  <!-- Dependencies -->');
-      for (const [id, content] of dependencies) {
-        // All dependencies are now wrapped in <file> elements
-        // Indent properly
-        const indentedContent = content
-          .split('\n')
-          .map((line) => '  ' + line)
-          .join('\n');
-        parts.push(indentedContent);
-      }
-    }
-    parts.push('</agent-bundle>');
-    return parts.join('\n');
-  }
-  /**
-   * Discover all modules
-   */
-  async discoverModules() {
-    const modules = [];
-    // Check for the built-in xmc module directly under src/
-    const xmcPath = getSourcePath('xmc');
-    if (await fs.pathExists(xmcPath)) {
-      modules.push('xmc');
-    }
-    if (modules.length === 0) {
-      console.log(chalk.yellow('No modules found under src/'));
-    }
-    return modules;
-  }
-  /**
-   * Discover agents in a module
-   */
-  async discoverAgents(modulePath) {
-    const agents = [];
-    const agentsPath = path.join(modulePath, 'agents');
-    if (!(await fs.pathExists(agentsPath))) {
-      return agents;
-    }
-    const files = await fs.readdir(agentsPath);
-    for (const file of files) {
-      // Look for .agent.yaml files (new format) or .md files (legacy format)
-      if (file.endsWith('.agent.yaml') || (file.endsWith('.md') && !file.toLowerCase().includes('readme'))) {
-        agents.push(file);
-      }
-    }
-    return agents;
-  }
-  /**
-   * Discover all teams in a module
-   */
-  async discoverTeams(modulePath) {
-    const teams = [];
-    const teamsPath = path.join(modulePath, 'teams');
-    if (!(await fs.pathExists(teamsPath))) {
-      return teams;
-    }
-    const files = await fs.readdir(teamsPath);
-    for (const file of files) {
-      if (file.endsWith('.yaml') || file.endsWith('.yml')) {
-        teams.push(file);
-      }
-    }
-    return teams;
-  }
-  /**
-   * Extract agent name from XML
-   */
-  getAgentName(xml) {
-    const match = xml.match(/<agent[^>]*name="([^"]+)"/);
-    return match ? match[1] : 'Unknown';
-  }
-  /**
-   * Extract agent description from XML
-   */
-  getAgentDescription(xml) {
-    const match = xml.match(/<description>([^<]+)<\/description>/);
-    return match ? match[1] : '';
-  }
-  /**
-   * Check if agent should be skipped for bundling
-   */
-  shouldSkipBundling(xml) {
-    // Check for bundle="false" attribute in the agent tag
-    const match = xml.match(/<agent[^>]*bundle="false"[^>]*>/);
-    return match !== null;
-  }
-  /**
-   * Create temporary manifest files
-   */
-  async createTempManifests() {
-    // Ensure temp directory exists
-    await fs.ensureDir(this.tempManifestDir);
-    // Generate agent-manifest.csv using shared generator
-    const agentPartyPath = path.join(this.tempManifestDir, 'agent-manifest.csv');
-    await AgentPartyGenerator.writeAgentParty(agentPartyPath, this.discoveredAgents, { forWeb: true });
-    console.log(chalk.dim('  ✓ Created temporary manifest files'));
-  }
-  /**
-   * Clean up temporary files
-   */
-  async cleanupTempFiles() {
-    if (await fs.pathExists(this.tempDir)) {
-      await fs.remove(this.tempDir);
-      console.log(chalk.dim('\n✓ Cleaned up temporary files'));
-    }
-  }
-  /**
-   * Validate XML content
-   */
-  async validateXml(xmlContent) {
-    try {
-      await xml2js.parseStringPromise(xmlContent, {
-        strict: true,
-        explicitArray: false,
-      });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Format XML content for readability
-   */
-  formatXml(xml) {
-    const TAB = '  '; // 2 spaces
-    let result = '';
-    let depth = 0;
-    // Split by tags while preserving them
-    const parts = xml.split(/(<[^>]+>)/g);
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      if (!part) continue;
-      if (part.startsWith('<?xml')) {
-        // XML declaration - no indent
-        result += part + '\n';
-      } else if (part.startsWith('<!--')) {
-        // Comment
-        result += TAB.repeat(depth) + part + '\n';
-      } else if (part.startsWith('</')) {
-        // Closing tag - unindent first
-        depth = Math.max(0, depth - 1);
-        result += TAB.repeat(depth) + part + '\n';
-      } else if (part.startsWith('<')) {
-        // Opening or self-closing tag
-        const isSelfClosing = part.endsWith('/>');
-        const tagName = part.match(/<(\w+)/)?.[1];
-        // Check if next part is simple text content
-        const nextPart = parts[i + 1];
-        const hasSimpleContent = nextPart && !nextPart.startsWith('<') && nextPart.trim().length > 0 && nextPart.trim().length <= 100;
-        if (hasSimpleContent && parts[i + 2] && parts[i + 2] === `</${tagName}>`) {
-          // Simple tag with inline content: <tag>content</tag>
-          result += TAB.repeat(depth) + part + nextPart.trim() + parts[i + 2] + '\n';
-          i += 2; // Skip content and closing tag
-        } else {
-          // Multi-line tag
-          result += TAB.repeat(depth) + part + '\n';
-          if (!isSelfClosing) {
-            depth++;
-          }
-        }
-      } else {
-        // Text content between tags
-        const trimmed = part.trim();
-        if (trimmed) {
-          result += TAB.repeat(depth) + trimmed + '\n';
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Display summary statistics
-   */
-  displaySummary() {
-    console.log(chalk.cyan.bold('\n═══════════════════════════════════════════════'));
-    console.log(chalk.cyan.bold('                 SUMMARY'));
-    console.log(chalk.cyan.bold('═══════════════════════════════════════════════\n'));
-    console.log(chalk.bold('Bundle Statistics:'));
-    console.log(`  Total agents found:    ${this.stats.totalAgents}`);
-    console.log(`  Successfully bundled:  ${chalk.green(this.stats.bundledAgents)}`);
-    if (this.stats.skippedAgents > 0) {
-      console.log(`  Skipped (webskip/bundle): ${chalk.gray(this.stats.skippedAgents)}`);
-    }
-    if (this.stats.failedAgents > 0) {
-      console.log(`  Failed to bundle:      ${chalk.red(this.stats.failedAgents)}`);
-    }
-    if (this.stats.invalidXml > 0) {
-      console.log(`  Invalid XML bundles:   ${chalk.yellow(this.stats.invalidXml)}`);
-    }
-    // Display warnings summary
-    // Check if there are actually any warnings with content
-    const hasActualWarnings = this.stats.warnings.some((w) => w && w.warnings && w.warnings.length > 0);
-    if (hasActualWarnings) {
-      console.log(chalk.yellow('\n⚠ Missing Dependencies by Agent:'));
-      // Group and display warnings by agent
-      for (const agentWarning of this.stats.warnings) {
-        if (agentWarning && agentWarning.warnings && agentWarning.warnings.length > 0) {
-          console.log(chalk.bold(`\n  ${agentWarning.agent}:`));
-          // Display unique warnings for this agent
-          const uniqueWarnings = [...new Set(agentWarning.warnings)];
-          for (const warning of uniqueWarnings) {
-            console.log(chalk.dim(`    • ${warning}`));
-          }
-        }
-      }
-    } else {
-      console.log(chalk.green('\n✓ No missing dependencies'));
-    }
-    // Final status
-    if (this.stats.invalidXml > 0) {
-      console.log(chalk.yellow('\n⚠ Some bundles have invalid XML. Please review the output.'));
-    } else if (this.stats.failedAgents > 0) {
-      console.log(chalk.yellow('\n⚠ Some agents failed to bundle. Please review the errors.'));
-    } else {
-      console.log(chalk.green('\n✨ All bundles generated successfully!'));
-    }
-    console.log(chalk.cyan.bold('\n═══════════════════════════════════════════════\n'));
-  }
-}
-module.exports = { WebBundler };