@zeyue0329/xiaoma-cli 1.0.37 → 1.0.39

package/tools/builders/web-builder.js

@@ -1,39 +1,39 @@
-const fs = require('node:fs').promises;
-const path = require('node:path');
-const DependencyResolver = require('../lib/dependency-resolver');
-const yamlUtilities = require('../lib/yaml-utils');
+const fs = require("node:fs").promises;
+const path = require("node:path");
+const DependencyResolver = require("../lib/dependency-resolver");
+const yamlUtilities = require("../lib/yaml-utils");
 
 class WebBuilder {
   constructor(options = {}) {
     this.rootDir = options.rootDir || process.cwd();
-    this.outputDirs = options.outputDirs || [path.join(this.rootDir, 'dist')];
+    this.outputDirs = options.outputDirs || [path.join(this.rootDir, "dist")];
     this.resolver = new DependencyResolver(this.rootDir);
     this.templatePath = path.join(
       this.rootDir,
-      'tools',
-      'md-assets',
-      'web-agent-startup-instructions.md',
+      "tools",
+      "md-assets",
+      "web-agent-startup-instructions.md",
     );
   }
 
   parseYaml(content) {
-    const yaml = require('js-yaml');
+    const yaml = require("js-yaml");
     return yaml.load(content);
   }
 
-  convertToWebPath(filePath, bundleRoot = 'xiaoma-core') {
+  convertToWebPath(filePath, bundleRoot = "xiaoma-core") {
     // Convert absolute paths to web bundle paths with dot prefix
     // All resources get installed under the bundle root, so use that path
     const relativePath = path.relative(this.rootDir, filePath);
     const pathParts = relativePath.split(path.sep);
 
     let resourcePath;
-    if (pathParts[0] === 'expansion-packs') {
+    if (pathParts[0] === "expansion-packs") {
       // For expansion packs, remove 'expansion-packs/packname' and use the rest
-      resourcePath = pathParts.slice(2).join('/');
+      resourcePath = pathParts.slice(2).join("/");
     } else {
       // For xiaoma-core, common, etc., remove the first part
-      resourcePath = pathParts.slice(1).join('/');
+      resourcePath = pathParts.slice(1).join("/");
     }
 
     return `.${bundleRoot}/${resourcePath}`;
@@ -41,22 +41,22 @@ class WebBuilder {
 
   generateWebInstructions(bundleType, packName = null) {
     // Generate dynamic web instructions based on bundle type
-    const rootExample = packName ? `.${packName}` : '.xiaoma-core';
+    const rootExample = packName ? `.${packName}` : ".xiaoma-core";
     const examplePath = packName
       ? `.${packName}/folder/filename.md`
-      : '.xiaoma-core/folder/filename.md';
+      : ".xiaoma-core/folder/filename.md";
     const personasExample = packName
       ? `.${packName}/personas/analyst.md`
-      : '.xiaoma-core/personas/analyst.md';
+      : ".xiaoma-core/personas/analyst.md";
     const tasksExample = packName
       ? `.${packName}/tasks/create-story.md`
-      : '.xiaoma-core/tasks/create-story.md';
+      : ".xiaoma-core/tasks/create-story.md";
     const utilitiesExample = packName
       ? `.${packName}/utils/template-format.md`
-      : '.xiaoma-core/utils/template-format.md';
+      : ".xiaoma-core/utils/template-format.md";
     const tasksReference = packName
       ? `.${packName}/tasks/create-story.md`
-      : '.xiaoma-core/tasks/create-story.md';
+      : ".xiaoma-core/tasks/create-story.md";
 
     return `# Web Agent Bundle Instructions
 
@@ -122,14 +122,16 @@ These references map directly to bundle sections:
 
       // Write to all output directories
       for (const outputDir of this.outputDirs) {
-        const outputPath = path.join(outputDir, 'agents');
+        const outputPath = path.join(outputDir, "agents");
         await fs.mkdir(outputPath, { recursive: true });
         const outputFile = path.join(outputPath, `${agentId}.txt`);
-        await fs.writeFile(outputFile, bundle, 'utf8');
+        await fs.writeFile(outputFile, bundle, "utf8");
       }
     }
 
-    console.log(`Built ${agents.length} agent bundles in ${this.outputDirs.length} locations`);
+    console.log(
+      `Built ${agents.length} agent bundles in ${this.outputDirs.length} locations`,
+    );
   }
 
   async buildTeams() {
@@ -141,58 +143,76 @@ These references map directly to bundle sections:
 
       // Write to all output directories
       for (const outputDir of this.outputDirs) {
-        const outputPath = path.join(outputDir, 'teams');
+        const outputPath = path.join(outputDir, "teams");
         await fs.mkdir(outputPath, { recursive: true });
         const outputFile = path.join(outputPath, `${teamId}.txt`);
-        await fs.writeFile(outputFile, bundle, 'utf8');
+        await fs.writeFile(outputFile, bundle, "utf8");
       }
     }
 
-    console.log(`Built ${teams.length} team bundles in ${this.outputDirs.length} locations`);
+    console.log(
+      `Built ${teams.length} team bundles in ${this.outputDirs.length} locations`,
+    );
   }
 
   async buildAgentBundle(agentId) {
     const dependencies = await this.resolver.resolveAgentDependencies(agentId);
-    const template = this.generateWebInstructions('agent');
+    const template = this.generateWebInstructions("agent");
 
     const sections = [template];
 
     // Add agent configuration
-    const agentPath = this.convertToWebPath(dependencies.agent.path, 'xiaoma-core');
-    sections.push(this.formatSection(agentPath, dependencies.agent.content, 'xiaoma-core'));
+    const agentPath = this.convertToWebPath(
+      dependencies.agent.path,
+      "xiaoma-core",
+    );
+    sections.push(
+      this.formatSection(agentPath, dependencies.agent.content, "xiaoma-core"),
+    );
 
     // Add all dependencies
     for (const resource of dependencies.resources) {
-      const resourcePath = this.convertToWebPath(resource.path, 'xiaoma-core');
-      sections.push(this.formatSection(resourcePath, resource.content, 'xiaoma-core'));
+      const resourcePath = this.convertToWebPath(resource.path, "xiaoma-core");
+      sections.push(
+        this.formatSection(resourcePath, resource.content, "xiaoma-core"),
+      );
     }
 
-    return sections.join('\n');
+    return sections.join("\n");
   }
 
   async buildTeamBundle(teamId) {
     const dependencies = await this.resolver.resolveTeamDependencies(teamId);
-    const template = this.generateWebInstructions('team');
+    const template = this.generateWebInstructions("team");
 
     const sections = [template];
 
     // Add team configuration
-    const teamPath = this.convertToWebPath(dependencies.team.path, 'xiaoma-core');
-    sections.push(this.formatSection(teamPath, dependencies.team.content, 'xiaoma-core'));
+    const teamPath = this.convertToWebPath(
+      dependencies.team.path,
+      "xiaoma-core",
+    );
+    sections.push(
+      this.formatSection(teamPath, dependencies.team.content, "xiaoma-core"),
+    );
 
     // Add all agents
     for (const agent of dependencies.agents) {
-      const agentPath = this.convertToWebPath(agent.path, 'xiaoma-core');
-      sections.push(this.formatSection(agentPath, agent.content, 'xiaoma-core'));
+      const agentPath = this.convertToWebPath(agent.path, "xiaoma-core");
+      sections.push(
+        this.formatSection(agentPath, agent.content, "xiaoma-core"),
+      );
     }
 
     // Add all deduplicated resources
     for (const resource of dependencies.resources) {
-      const resourcePath = this.convertToWebPath(resource.path, 'xiaoma-core');
-      sections.push(this.formatSection(resourcePath, resource.content, 'xiaoma-core'));
+      const resourcePath = this.convertToWebPath(resource.path, "xiaoma-core");
+      sections.push(
+        this.formatSection(resourcePath, resource.content, "xiaoma-core"),
+      );
     }
 
-    return sections.join('\n');
+    return sections.join("\n");
   }
 
   processAgentContent(content) {
@@ -208,50 +228,53 @@ These references map directly to bundle sections:
 
     // Parse YAML and remove root and IDE-FILE-RESOLUTION properties
     try {
-      const yaml = require('js-yaml');
+      const yaml = require("js-yaml");
       const parsed = yaml.load(yamlContent);
 
       // Remove the properties if they exist at root level
       delete parsed.root;
-      delete parsed['IDE-FILE-RESOLUTION'];
-      delete parsed['REQUEST-RESOLUTION'];
+      delete parsed["IDE-FILE-RESOLUTION"];
+      delete parsed["REQUEST-RESOLUTION"];
 
       // Also remove from activation-instructions if they exist
-      if (parsed['activation-instructions'] && Array.isArray(parsed['activation-instructions'])) {
-        parsed['activation-instructions'] = parsed['activation-instructions'].filter(
-          (instruction) => {
-            return (
-              typeof instruction === 'string' &&
-              !instruction.startsWith('IDE-FILE-RESOLUTION:') &&
-              !instruction.startsWith('REQUEST-RESOLUTION:')
-            );
-          },
-        );
+      if (
+        parsed["activation-instructions"] &&
+        Array.isArray(parsed["activation-instructions"])
+      ) {
+        parsed["activation-instructions"] = parsed[
+          "activation-instructions"
+        ].filter((instruction) => {
+          return (
+            typeof instruction === "string" &&
+            !instruction.startsWith("IDE-FILE-RESOLUTION:") &&
+            !instruction.startsWith("REQUEST-RESOLUTION:")
+          );
+        });
       }
 
       // Reconstruct the YAML
       const cleanedYaml = yaml.dump(parsed, { lineWidth: -1 });
 
       // Get the agent name from the YAML for the header
-      const agentName = parsed.agent?.id || 'agent';
+      const agentName = parsed.agent?.id || "agent";
 
       // Build the new content with just the agent header and YAML
       const newHeader = `# ${agentName}\n\nCRITICAL: Read the full YAML, start activation to alter your state of being, follow startup section instructions, stay in this being until told to exit this mode:\n\n`;
       const afterYaml = content.slice(Math.max(0, yamlEndIndex));
 
-      return newHeader + '```yaml\n' + cleanedYaml.trim() + '\n```' + afterYaml;
+      return newHeader + "```yaml\n" + cleanedYaml.trim() + "\n```" + afterYaml;
     } catch (error) {
-      console.warn('Failed to process agent YAML:', error.message);
+      console.warn("Failed to process agent YAML:", error.message);
       // If parsing fails, return original content
       return content;
     }
   }
 
-  formatSection(path, content, bundleRoot = 'xiaoma-core') {
-    const separator = '====================';
+  formatSection(path, content, bundleRoot = "xiaoma-core") {
+    const separator = "====================";
 
     // Process agent content if this is an agent file
-    if (path.includes('/agents/')) {
+    if (path.includes("/agents/")) {
       content = this.processAgentContent(content);
     }
 
@@ -262,17 +285,17 @@ These references map directly to bundle sections:
       `${separator} START: ${path} ${separator}`,
       content.trim(),
       `${separator} END: ${path} ${separator}`,
-      '',
-    ].join('\n');
+      "",
+    ].join("\n");
   }
 
   replaceRootReferences(content, bundleRoot) {
     // Replace {root} with the appropriate bundle root path
-    return content.replaceAll('{root}', `.${bundleRoot}`);
+    return content.replaceAll("{root}", `.${bundleRoot}`);
   }
 
   async validate() {
-    console.log('Validating agent configurations...');
+    console.log("Validating agent configurations...");
     const agents = await this.resolver.listAgents();
     for (const agentId of agents) {
       try {
@@ -284,7 +307,7 @@ These references map directly to bundle sections:
       }
     }
 
-    console.log('\nValidating team configurations...');
+    console.log("\nValidating team configurations...");
     const teams = await this.resolver.listTeams();
     for (const teamId of teams) {
       try {
@@ -309,8 +332,10 @@ These references map directly to bundle sections:
   }
 
   async buildExpansionPack(packName, options = {}) {
-    const packDir = path.join(this.rootDir, 'expansion-packs', packName);
-    const outputDirectories = [path.join(this.rootDir, 'dist', 'expansion-packs', packName)];
+    const packDir = path.join(this.rootDir, "expansion-packs", packName);
+    const outputDirectories = [
+      path.join(this.rootDir, "dist", "expansion-packs", packName),
+    ];
 
     // Clean output directories if requested
     if (options.clean !== false) {
@@ -324,27 +349,31 @@ These references map directly to bundle sections:
     }
 
     // Build individual agents first
-    const agentsDir = path.join(packDir, 'agents');
+    const agentsDir = path.join(packDir, "agents");
     try {
       const agentFiles = await fs.readdir(agentsDir);
-      const agentMarkdownFiles = agentFiles.filter((f) => f.endsWith('.md'));
+      const agentMarkdownFiles = agentFiles.filter((f) => f.endsWith(".md"));
 
       if (agentMarkdownFiles.length > 0) {
         console.log(`    Building individual agents for ${packName}:`);
 
         for (const agentFile of agentMarkdownFiles) {
-          const agentName = agentFile.replace('.md', '');
+          const agentName = agentFile.replace(".md", "");
           console.log(`      - ${agentName}`);
 
           // Build individual agent bundle
-          const bundle = await this.buildExpansionAgentBundle(packName, packDir, agentName);
+          const bundle = await this.buildExpansionAgentBundle(
+            packName,
+            packDir,
+            agentName,
+          );
 
           // Write to all output directories
           for (const outputDir of outputDirectories) {
-            const agentsOutputDir = path.join(outputDir, 'agents');
+            const agentsOutputDir = path.join(outputDir, "agents");
             await fs.mkdir(agentsOutputDir, { recursive: true });
             const outputFile = path.join(agentsOutputDir, `${agentName}.txt`);
-            await fs.writeFile(outputFile, bundle, 'utf8');
+            await fs.writeFile(outputFile, bundle, "utf8");
           }
         }
       }
@@ -353,28 +382,39 @@ These references map directly to bundle sections:
     }
 
     // Build team bundle
-    const agentTeamsDir = path.join(packDir, 'agent-teams');
+    const agentTeamsDir = path.join(packDir, "agent-teams");
     try {
       const teamFiles = await fs.readdir(agentTeamsDir);
-      const teamFile = teamFiles.find((f) => f.endsWith('.yaml'));
+      const teamFile = teamFiles.find((f) => f.endsWith(".yaml"));
 
       if (teamFile) {
         console.log(`    Building team bundle for ${packName}`);
         const teamConfigPath = path.join(agentTeamsDir, teamFile);
 
         // Build expansion pack as a team bundle
-        const bundle = await this.buildExpansionTeamBundle(packName, packDir, teamConfigPath);
+        const bundle = await this.buildExpansionTeamBundle(
+          packName,
+          packDir,
+          teamConfigPath,
+        );
 
         // Write to all output directories
         for (const outputDir of outputDirectories) {
-          const teamsOutputDir = path.join(outputDir, 'teams');
+          const teamsOutputDir = path.join(outputDir, "teams");
           await fs.mkdir(teamsOutputDir, { recursive: true });
-          const outputFile = path.join(teamsOutputDir, teamFile.replace('.yaml', '.txt'));
-          await fs.writeFile(outputFile, bundle, 'utf8');
-          console.log(`    ✓ Created bundle: ${path.relative(this.rootDir, outputFile)}`);
+          const outputFile = path.join(
+            teamsOutputDir,
+            teamFile.replace(".yaml", ".txt"),
+          );
+          await fs.writeFile(outputFile, bundle, "utf8");
+          console.log(
+            `    ✓ Created bundle: ${path.relative(this.rootDir, outputFile)}`,
+          );
         }
       } else {
-        console.warn(`    ⚠ No team configuration found in ${packName}/agent-teams/`);
+        console.warn(
+          `    ⚠ No team configuration found in ${packName}/agent-teams/`,
+        );
       }
     } catch {
       console.warn(`    ⚠ No agent-teams directory found for ${packName}`);
@@ -382,12 +422,12 @@ These references map directly to bundle sections:
   }
 
   async buildExpansionAgentBundle(packName, packDir, agentName) {
-    const template = this.generateWebInstructions('expansion-agent', packName);
+    const template = this.generateWebInstructions("expansion-agent", packName);
     const sections = [template];
 
     // Add agent configuration
-    const agentPath = path.join(packDir, 'agents', `${agentName}.md`);
-    const agentContent = await fs.readFile(agentPath, 'utf8');
+    const agentPath = path.join(packDir, "agents", `${agentName}.md`);
+    const agentContent = await fs.readFile(agentPath, "utf8");
     const agentWebPath = this.convertToWebPath(agentPath, packName);
     sections.push(this.formatSection(agentWebPath, agentContent, packName));
 
@@ -395,22 +435,40 @@ These references map directly to bundle sections:
     const yamlContent = yamlUtilities.extractYamlFromAgent(agentContent);
     if (yamlContent) {
       try {
-        const yaml = require('js-yaml');
+        const yaml = require("js-yaml");
         const agentConfig = yaml.load(yamlContent);
 
         if (agentConfig.dependencies) {
           // Add resources, first try expansion pack, then core
-          for (const [resourceType, resources] of Object.entries(agentConfig.dependencies)) {
+          for (const [resourceType, resources] of Object.entries(
+            agentConfig.dependencies,
+          )) {
             if (Array.isArray(resources)) {
               for (const resourceName of resources) {
                 let found = false;
 
                 // Try expansion pack first
-                const resourcePath = path.join(packDir, resourceType, resourceName);
+                const resourcePath = path.join(
+                  packDir,
+                  resourceType,
+                  resourceName,
+                );
                 try {
-                  const resourceContent = await fs.readFile(resourcePath, 'utf8');
-                  const resourceWebPath = this.convertToWebPath(resourcePath, packName);
-                  sections.push(this.formatSection(resourceWebPath, resourceContent, packName));
+                  const resourceContent = await fs.readFile(
+                    resourcePath,
+                    "utf8",
+                  );
+                  const resourceWebPath = this.convertToWebPath(
+                    resourcePath,
+                    packName,
+                  );
+                  sections.push(
+                    this.formatSection(
+                      resourceWebPath,
+                      resourceContent,
+                      packName,
+                    ),
+                  );
                   found = true;
                 } catch {
                   // Not in expansion pack, continue
@@ -420,14 +478,19 @@ These references map directly to bundle sections:
                 if (!found) {
                   const corePath = path.join(
                     this.rootDir,
-                    'xiaoma-core',
+                    "xiaoma-core",
                     resourceType,
                     resourceName,
                   );
                   try {
-                    const coreContent = await fs.readFile(corePath, 'utf8');
-                    const coreWebPath = this.convertToWebPath(corePath, packName);
-                    sections.push(this.formatSection(coreWebPath, coreContent, packName));
+                    const coreContent = await fs.readFile(corePath, "utf8");
+                    const coreWebPath = this.convertToWebPath(
+                      corePath,
+                      packName,
+                    );
+                    sections.push(
+                      this.formatSection(coreWebPath, coreContent, packName),
+                    );
                     found = true;
                   } catch {
                     // Not in core either, continue
@@ -436,11 +499,25 @@ These references map directly to bundle sections:
 
                 // If not found in core, try common folder
                 if (!found) {
-                  const commonPath = path.join(this.rootDir, 'common', resourceType, resourceName);
+                  const commonPath = path.join(
+                    this.rootDir,
+                    "common",
+                    resourceType,
+                    resourceName,
+                  );
                   try {
-                    const commonContent = await fs.readFile(commonPath, 'utf8');
-                    const commonWebPath = this.convertToWebPath(commonPath, packName);
-                    sections.push(this.formatSection(commonWebPath, commonContent, packName));
+                    const commonContent = await fs.readFile(commonPath, "utf8");
+                    const commonWebPath = this.convertToWebPath(
+                      commonPath,
+                      packName,
+                    );
+                    sections.push(
+                      this.formatSection(
+                        commonWebPath,
+                        commonContent,
+                        packName,
+                      ),
+                    );
                     found = true;
                   } catch {
                     // Not in common either, continue
@@ -457,32 +534,35 @@ These references map directly to bundle sections:
           }
         }
       } catch (error) {
-        console.debug(`Failed to parse agent YAML for ${agentName}:`, error.message);
+        console.debug(
+          `Failed to parse agent YAML for ${agentName}:`,
+          error.message,
+        );
       }
     }
 
-    return sections.join('\n');
+    return sections.join("\n");
   }
 
   async buildExpansionTeamBundle(packName, packDir, teamConfigPath) {
-    const template = this.generateWebInstructions('expansion-team', packName);
+    const template = this.generateWebInstructions("expansion-team", packName);
 
     const sections = [template];
 
     // Add team configuration and parse to get agent list
-    const teamContent = await fs.readFile(teamConfigPath, 'utf8');
-    const teamFileName = path.basename(teamConfigPath, '.yaml');
+    const teamContent = await fs.readFile(teamConfigPath, "utf8");
+    const teamFileName = path.basename(teamConfigPath, ".yaml");
     const teamConfig = this.parseYaml(teamContent);
     const teamWebPath = this.convertToWebPath(teamConfigPath, packName);
     sections.push(this.formatSection(teamWebPath, teamContent, packName));
 
     // Get list of expansion pack agents
     const expansionAgents = new Set();
-    const agentsDir = path.join(packDir, 'agents');
+    const agentsDir = path.join(packDir, "agents");
     try {
       const agentFiles = await fs.readdir(agentsDir);
-      for (const agentFile of agentFiles.filter((f) => f.endsWith('.md'))) {
-        const agentName = agentFile.replace('.md', '');
+      for (const agentFile of agentFiles.filter((f) => f.endsWith(".md"))) {
+        const agentName = agentFile.replace(".md", "");
         expansionAgents.add(agentName);
       }
     } catch {
@@ -491,13 +571,19 @@ These references map directly to bundle sections:
 
     // Build a map of all available expansion pack resources for override checking
     const expansionResources = new Map();
-    const resourceDirectories = ['templates', 'tasks', 'checklists', 'workflows', 'data'];
+    const resourceDirectories = [
+      "templates",
+      "tasks",
+      "checklists",
+      "workflows",
+      "data",
+    ];
     for (const resourceDir of resourceDirectories) {
       const resourcePath = path.join(packDir, resourceDir);
       try {
         const resourceFiles = await fs.readdir(resourcePath);
         for (const resourceFile of resourceFiles.filter(
-          (f) => f.endsWith('.md') || f.endsWith('.yaml'),
+          (f) => f.endsWith(".md") || f.endsWith(".yaml"),
         )) {
           expansionResources.set(`${resourceDir}#${resourceFile}`, true);
         }
@@ -510,9 +596,11 @@ These references map directly to bundle sections:
     const agentsToProcess = teamConfig.agents || [];
 
     // Ensure xiaoma-orchestrator is always included for teams
-    if (!agentsToProcess.includes('xiaoma-orchestrator')) {
-      console.warn(`    ⚠ Team ${teamFileName} missing xiaoma-orchestrator, adding automatically`);
-      agentsToProcess.unshift('xiaoma-orchestrator');
+    if (!agentsToProcess.includes("xiaoma-orchestrator")) {
+      console.warn(
+        `    ⚠ Team ${teamFileName} missing xiaoma-orchestrator, adding automatically`,
+      );
+      agentsToProcess.unshift("xiaoma-orchestrator");
     }
 
     // Track all dependencies from all agents (deduplicated)
@@ -522,9 +610,14 @@ These references map directly to bundle sections:
       if (expansionAgents.has(agentId)) {
         // Use expansion pack version (override)
         const agentPath = path.join(agentsDir, `${agentId}.md`);
-        const agentContent = await fs.readFile(agentPath, 'utf8');
-        const expansionAgentWebPath = this.convertToWebPath(agentPath, packName);
-        sections.push(this.formatSection(expansionAgentWebPath, agentContent, packName));
+        const agentContent = await fs.readFile(agentPath, "utf8");
+        const expansionAgentWebPath = this.convertToWebPath(
+          agentPath,
+          packName,
+        );
+        sections.push(
+          this.formatSection(expansionAgentWebPath, agentContent, packName),
+        );
 
         // Parse and collect dependencies from expansion agent
         const agentYaml = agentContent.match(/```yaml\n([\s\S]*?)\n```/);
@@ -532,52 +625,83 @@ These references map directly to bundle sections:
           try {
             const agentConfig = this.parseYaml(agentYaml[1]);
             if (agentConfig.dependencies) {
-              for (const [resourceType, resources] of Object.entries(agentConfig.dependencies)) {
+              for (const [resourceType, resources] of Object.entries(
+                agentConfig.dependencies,
+              )) {
                 if (Array.isArray(resources)) {
                   for (const resourceName of resources) {
                     const key = `${resourceType}#${resourceName}`;
                     if (!allDependencies.has(key)) {
-                      allDependencies.set(key, { type: resourceType, name: resourceName });
+                      allDependencies.set(key, {
+                        type: resourceType,
+                        name: resourceName,
+                      });
                     }
                   }
                 }
               }
             }
           } catch (error) {
-            console.debug(`Failed to parse agent YAML for ${agentId}:`, error.message);
+            console.debug(
+              `Failed to parse agent YAML for ${agentId}:`,
+              error.message,
+            );
           }
         }
       } else {
         // Use core BMad version
         try {
-          const coreAgentPath = path.join(this.rootDir, 'xiaoma-core', 'agents', `${agentId}.md`);
-          const coreAgentContent = await fs.readFile(coreAgentPath, 'utf8');
-          const coreAgentWebPath = this.convertToWebPath(coreAgentPath, packName);
-          sections.push(this.formatSection(coreAgentWebPath, coreAgentContent, packName));
+          const coreAgentPath = path.join(
+            this.rootDir,
+            "xiaoma-core",
+            "agents",
+            `${agentId}.md`,
+          );
+          const coreAgentContent = await fs.readFile(coreAgentPath, "utf8");
+          const coreAgentWebPath = this.convertToWebPath(
+            coreAgentPath,
+            packName,
+          );
+          sections.push(
+            this.formatSection(coreAgentWebPath, coreAgentContent, packName),
+          );
 
           // Parse and collect dependencies from core agent
-          const yamlContent = yamlUtilities.extractYamlFromAgent(coreAgentContent, true);
+          const yamlContent = yamlUtilities.extractYamlFromAgent(
+            coreAgentContent,
+            true,
+          );
           if (yamlContent) {
             try {
               const agentConfig = this.parseYaml(yamlContent);
               if (agentConfig.dependencies) {
-                for (const [resourceType, resources] of Object.entries(agentConfig.dependencies)) {
+                for (const [resourceType, resources] of Object.entries(
+                  agentConfig.dependencies,
+                )) {
                   if (Array.isArray(resources)) {
                     for (const resourceName of resources) {
                       const key = `${resourceType}#${resourceName}`;
                       if (!allDependencies.has(key)) {
-                        allDependencies.set(key, { type: resourceType, name: resourceName });
+                        allDependencies.set(key, {
+                          type: resourceType,
+                          name: resourceName,
+                        });
                       }
                     }
                   }
                 }
               }
             } catch (error) {
-              console.debug(`Failed to parse agent YAML for ${agentId}:`, error.message);
+              console.debug(
+                `Failed to parse agent YAML for ${agentId}:`,
+                error.message,
+              );
             }
           }
         } catch {
-          console.warn(`    ⚠ Agent ${agentId} not found in core or expansion pack`);
+          console.warn(
+            `    ⚠ Agent ${agentId} not found in core or expansion pack`,
+          );
         }
       }
     }
@@ -592,9 +716,14 @@ These references map directly to bundle sections:
         // We know it exists in expansion pack, find and load it
         const expansionPath = path.join(packDir, dep.type, dep.name);
         try {
-          const content = await fs.readFile(expansionPath, 'utf8');
-          const expansionWebPath = this.convertToWebPath(expansionPath, packName);
-          sections.push(this.formatSection(expansionWebPath, content, packName));
+          const content = await fs.readFile(expansionPath, "utf8");
+          const expansionWebPath = this.convertToWebPath(
+            expansionPath,
+            packName,
+          );
+          sections.push(
+            this.formatSection(expansionWebPath, content, packName),
+          );
           console.log(`      ✓ Using expansion override for ${key}`);
           found = true;
         } catch {
@@ -604,9 +733,14 @@ These references map directly to bundle sections:
 
       // If not found in expansion pack (or doesn't exist there), try core
       if (!found) {
-        const corePath = path.join(this.rootDir, 'xiaoma-core', dep.type, dep.name);
+        const corePath = path.join(
+          this.rootDir,
+          "xiaoma-core",
+          dep.type,
+          dep.name,
+        );
         try {
-          const content = await fs.readFile(corePath, 'utf8');
+          const content = await fs.readFile(corePath, "utf8");
           const coreWebPath = this.convertToWebPath(corePath, packName);
           sections.push(this.formatSection(coreWebPath, content, packName));
           found = true;
@@ -617,9 +751,14 @@ These references map directly to bundle sections:
 
       // If not found in core, try common folder
       if (!found) {
-        const commonPath = path.join(this.rootDir, 'common', dep.type, dep.name);
+        const commonPath = path.join(
+          this.rootDir,
+          "common",
+          dep.type,
+          dep.name,
+        );
         try {
-          const content = await fs.readFile(commonPath, 'utf8');
+          const content = await fs.readFile(commonPath, "utf8");
           const commonWebPath = this.convertToWebPath(commonPath, packName);
           sections.push(this.formatSection(commonWebPath, content, packName));
           found = true;
@@ -629,7 +768,9 @@ These references map directly to bundle sections:
       }
 
       if (!found) {
-        console.warn(`    ⚠ Dependency ${key} not found in expansion pack or core`);
+        console.warn(
+          `    ⚠ Dependency ${key} not found in expansion pack or core`,
+        );
       }
     }
 
@@ -639,18 +780,23 @@ These references map directly to bundle sections:
       try {
         const resourceFiles = await fs.readdir(resourcePath);
         for (const resourceFile of resourceFiles.filter(
-          (f) => f.endsWith('.md') || f.endsWith('.yaml'),
+          (f) => f.endsWith(".md") || f.endsWith(".yaml"),
         )) {
           const filePath = path.join(resourcePath, resourceFile);
-          const fileContent = await fs.readFile(filePath, 'utf8');
-          const fileName = resourceFile.replace(/\.(md|yaml)$/, '');
+          const fileContent = await fs.readFile(filePath, "utf8");
+          const fileName = resourceFile.replace(/\.(md|yaml)$/, "");
 
           // Only add if not already included as a dependency
           const resourceKey = `${resourceDir}#${fileName}`;
           if (!allDependencies.has(resourceKey)) {
             const fullResourcePath = path.join(resourcePath, resourceFile);
-            const resourceWebPath = this.convertToWebPath(fullResourcePath, packName);
-            sections.push(this.formatSection(resourceWebPath, fileContent, packName));
+            const resourceWebPath = this.convertToWebPath(
+              fullResourcePath,
+              packName,
+            );
+            sections.push(
+              this.formatSection(resourceWebPath, fileContent, packName),
+            );
           }
         }
       } catch {
@@ -658,16 +804,20 @@ These references map directly to bundle sections:
       }
     }
 
-    return sections.join('\n');
+    return sections.join("\n");
   }
 
   async listExpansionPacks() {
-    const expansionPacksDir = path.join(this.rootDir, 'expansion-packs');
+    const expansionPacksDir = path.join(this.rootDir, "expansion-packs");
     try {
-      const entries = await fs.readdir(expansionPacksDir, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+      const entries = await fs.readdir(expansionPacksDir, {
+        withFileTypes: true,
+      });
+      return entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
     } catch {
-      console.warn('No expansion-packs directory found');
+      console.warn("No expansion-packs directory found");
       return [];
     }
   }