@zeyue0329/xiaoma-cli 1.0.49 → 6.0.0-alpha.14

package/tools/cli/installers/lib/ide/shared/module-injections.js

@@ -0,0 +1,133 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+const { glob } = require('glob');
+const { getSourcePath } = require('../../../../lib/project-root');
+
+async function loadModuleInjectionConfig(handler, moduleName) {
+  const sourceModulesPath = getSourcePath('modules');
+  const handlerBaseDir = path.join(sourceModulesPath, moduleName, 'sub-modules', handler);
+  const configPath = path.join(handlerBaseDir, 'injections.yaml');
+
+  if (!(await fs.pathExists(configPath))) {
+    return null;
+  }
+
+  const configContent = await fs.readFile(configPath, 'utf8');
+  const config = yaml.load(configContent) || {};
+
+  return {
+    config,
+    handlerBaseDir,
+    configPath,
+  };
+}
+
+function shouldApplyInjection(injection, subagentChoices) {
+  if (!subagentChoices || subagentChoices.install === 'none') {
+    return false;
+  }
+
+  if (subagentChoices.install === 'all') {
+    return true;
+  }
+
+  if (subagentChoices.install === 'selective') {
+    const selected = subagentChoices.selected || [];
+
+    if (injection.requires === 'any' && selected.length > 0) {
+      return true;
+    }
+
+    if (injection.requires) {
+      const required = `${injection.requires}.md`;
+      return selected.includes(required);
+    }
+
+    if (injection.point) {
+      const selectedNames = selected.map((file) => file.replace('.md', ''));
+      return selectedNames.some((name) => injection.point.includes(name));
+    }
+  }
+
+  return false;
+}
+
+function filterAgentInstructions(content, selectedFiles) {
+  if (!selectedFiles || selectedFiles.length === 0) {
+    return '';
+  }
+
+  const selectedAgents = selectedFiles.map((file) => file.replace('.md', ''));
+  const lines = content.split('\n');
+  const filteredLines = [];
+
+  for (const line of lines) {
+    if (line.includes('<llm') || line.includes('</llm>')) {
+      filteredLines.push(line);
+    } else if (line.includes('subagent')) {
+      let shouldInclude = false;
+      for (const agent of selectedAgents) {
+        if (line.includes(agent)) {
+          shouldInclude = true;
+          break;
+        }
+      }
+
+      if (shouldInclude) {
+        filteredLines.push(line);
+      }
+    } else if (line.includes('When creating PRDs') || line.includes('ACTIVELY delegate')) {
+      filteredLines.push(line);
+    }
+  }
+
+  if (filteredLines.length > 2) {
+    return filteredLines.join('\n');
+  }
+
+  return '';
+}
+
+async function resolveSubagentFiles(handlerBaseDir, subagentConfig, subagentChoices) {
+  if (!subagentConfig || !subagentConfig.files) {
+    return [];
+  }
+
+  if (!subagentChoices || subagentChoices.install === 'none') {
+    return [];
+  }
+
+  let filesToCopy = subagentConfig.files;
+
+  if (subagentChoices.install === 'selective') {
+    filesToCopy = subagentChoices.selected || [];
+  }
+
+  const sourceDir = path.join(handlerBaseDir, subagentConfig.source || '');
+  const resolved = [];
+
+  for (const file of filesToCopy) {
+    const pattern = path.join(sourceDir, '**', file);
+    const matches = await glob(pattern);
+
+    if (matches.length > 0) {
+      const absolutePath = matches[0];
+      resolved.push({
+        file,
+        absolutePath,
+        relativePath: path.relative(sourceDir, absolutePath),
+        sourceDir,
+      });
+    }
+  }
+
+  return resolved;
+}
+
+module.exports = {
+  loadModuleInjectionConfig,
+  shouldApplyInjection,
+  filterAgentInstructions,
+  resolveSubagentFiles,
+};

package/tools/cli/installers/lib/ide/shared/task-tool-command-generator.js

@@ -0,0 +1,119 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const chalk = require('chalk');
+
+/**
+ * Generates command files for standalone tasks and tools
+ */
+class TaskToolCommandGenerator {
+  /**
+   * Generate task and tool commands from manifest CSVs
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {string} baseCommandsDir - Optional base commands directory (defaults to .claude/commands/xiaoma)
+   */
+  async generateTaskToolCommands(projectDir, xiaomaDir, baseCommandsDir = null) {
+    const tasks = await this.loadTaskManifest(xiaomaDir);
+    const tools = await this.loadToolManifest(xiaomaDir);
+
+    // Filter to only standalone items
+    const standaloneTasks = tasks ? tasks.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+    const standaloneTools = tools ? tools.filter((t) => t.standalone === 'true' || t.standalone === true) : [];
+
+    // Base commands directory - use provided or default to Claude Code structure
+    const commandsDir = baseCommandsDir || path.join(projectDir, '.claude', 'commands', 'xiaoma');
+
+    let generatedCount = 0;
+
+    // Generate command files for tasks
+    for (const task of standaloneTasks) {
+      const moduleTasksDir = path.join(commandsDir, task.module, 'tasks');
+      await fs.ensureDir(moduleTasksDir);
+
+      const commandContent = this.generateCommandContent(task, 'task');
+      const commandPath = path.join(moduleTasksDir, `${task.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Generate command files for tools
+    for (const tool of standaloneTools) {
+      const moduleToolsDir = path.join(commandsDir, tool.module, 'tools');
+      await fs.ensureDir(moduleToolsDir);
+
+      const commandContent = this.generateCommandContent(tool, 'tool');
+      const commandPath = path.join(moduleToolsDir, `${tool.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    return {
+      generated: generatedCount,
+      tasks: standaloneTasks.length,
+      tools: standaloneTools.length,
+    };
+  }
+
+  /**
+   * Generate command content for a task or tool
+   */
+  generateCommandContent(item, type) {
+    const description = item.description || `Execute ${item.displayName || item.name}`;
+
+    // Convert path to use {project-root} placeholder
+    let itemPath = item.path;
+    if (itemPath.startsWith('xiaoma/')) {
+      itemPath = `{project-root}/${itemPath}`;
+    }
+
+    return `---
+description: '${description.replaceAll("'", "''")}'
+---
+
+# ${item.displayName || item.name}
+
+LOAD and execute the ${type} at: ${itemPath}
+
+Follow all instructions in the ${type} file exactly as written.
+`;
+  }
+
+  /**
+   * Load task manifest CSV
+   */
+  async loadTaskManifest(xiaomaDir) {
+    const manifestPath = path.join(xiaomaDir, '_cfg', 'task-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+  }
+
+  /**
+   * Load tool manifest CSV
+   */
+  async loadToolManifest(xiaomaDir) {
+    const manifestPath = path.join(xiaomaDir, '_cfg', 'tool-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+  }
+}
+
+module.exports = { TaskToolCommandGenerator };

package/tools/cli/installers/lib/ide/shared/workflow-command-generator.js

@@ -0,0 +1,237 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const csv = require('csv-parse/sync');
+const chalk = require('chalk');
+
+/**
+ * Generates command files for each workflow in the manifest
+ */
+class WorkflowCommandGenerator {
+  constructor(xiaomaFolderName = 'xiaoma') {
+    this.templatePath = path.join(__dirname, '../templates/workflow-command-template.md');
+    this.xiaomaFolderName = xiaomaFolderName;
+  }
+
+  /**
+   * Generate workflow commands from the manifest CSV
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   */
+  async generateWorkflowCommands(projectDir, xiaomaDir) {
+    const workflows = await this.loadWorkflowManifest(xiaomaDir);
+
+    if (!workflows) {
+      console.log(chalk.yellow('Workflow manifest not found. Skipping command generation.'));
+      return { generated: 0 };
+    }
+
+    // Filter to only standalone workflows
+    const standaloneWorkflows = workflows.filter((w) => w.standalone === 'true' || w.standalone === true);
+
+    // Base commands directory
+    const baseCommandsDir = path.join(projectDir, '.claude', 'commands', 'xiaoma');
+
+    let generatedCount = 0;
+
+    // Generate a command file for each standalone workflow, organized by module
+    for (const workflow of standaloneWorkflows) {
+      const moduleWorkflowsDir = path.join(baseCommandsDir, workflow.module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+
+      const commandContent = await this.generateCommandContent(workflow, xiaomaDir);
+      const commandPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
+
+      await fs.writeFile(commandPath, commandContent);
+      generatedCount++;
+    }
+
+    // Also create a workflow launcher README in each module
+    const groupedWorkflows = this.groupWorkflowsByModule(standaloneWorkflows);
+    await this.createModuleWorkflowLaunchers(baseCommandsDir, groupedWorkflows);
+
+    return { generated: generatedCount };
+  }
+
+  async collectWorkflowArtifacts(xiaomaDir) {
+    const workflows = await this.loadWorkflowManifest(xiaomaDir);
+
+    if (!workflows) {
+      return { artifacts: [], counts: { commands: 0, launchers: 0 } };
+    }
+
+    // Filter to only standalone workflows
+    const standaloneWorkflows = workflows.filter((w) => w.standalone === 'true' || w.standalone === true);
+
+    const artifacts = [];
+
+    for (const workflow of standaloneWorkflows) {
+      const commandContent = await this.generateCommandContent(workflow, xiaomaDir);
+      artifacts.push({
+        type: 'workflow-command',
+        module: workflow.module,
+        relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
+        content: commandContent,
+        sourcePath: workflow.path,
+      });
+    }
+
+    const groupedWorkflows = this.groupWorkflowsByModule(standaloneWorkflows);
+    for (const [module, launcherContent] of Object.entries(this.buildModuleWorkflowLaunchers(groupedWorkflows))) {
+      artifacts.push({
+        type: 'workflow-launcher',
+        module,
+        relativePath: path.join(module, 'workflows', 'README.md'),
+        content: launcherContent,
+        sourcePath: null,
+      });
+    }
+
+    return {
+      artifacts,
+      counts: {
+        commands: standaloneWorkflows.length,
+        launchers: Object.keys(groupedWorkflows).length,
+      },
+    };
+  }
+
+  /**
+   * Generate command content for a workflow
+   */
+  async generateCommandContent(workflow, xiaomaDir) {
+    // Load the template
+    const template = await fs.readFile(this.templatePath, 'utf8');
+
+    // Convert source path to installed path
+    // From: /Users/.../src/modules/xmc/workflows/.../workflow.yaml
+    // To: {project-root}/{xiaoma_folder}/xmc/workflows/.../workflow.yaml
+    let workflowPath = workflow.path;
+
+    // Extract the relative path from source
+    if (workflowPath.includes('/src/modules/')) {
+      const match = workflowPath.match(/\/src\/modules\/(.+)/);
+      if (match) {
+        workflowPath = `${this.xiaomaFolderName}/${match[1]}`;
+      }
+    } else if (workflowPath.includes('/src/core/')) {
+      const match = workflowPath.match(/\/src\/core\/(.+)/);
+      if (match) {
+        workflowPath = `${this.xiaomaFolderName}/core/${match[1]}`;
+      }
+    }
+
+    // Replace template variables
+    return template
+      .replaceAll('{{name}}', workflow.name)
+      .replaceAll('{{module}}', workflow.module)
+      .replaceAll('{{description}}', workflow.description)
+      .replaceAll('{{workflow_path}}', workflowPath)
+      .replaceAll('{xiaoma_folder}', this.xiaomaFolderName)
+      .replaceAll('{{interactive}}', workflow.interactive)
+      .replaceAll('{{author}}', workflow.author || 'XIAOMA');
+  }
+
+  /**
+   * Create workflow launcher files for each module
+   */
+  async createModuleWorkflowLaunchers(baseCommandsDir, workflowsByModule) {
+    for (const [module, moduleWorkflows] of Object.entries(workflowsByModule)) {
+      const content = this.buildLauncherContent(module, moduleWorkflows);
+      const moduleWorkflowsDir = path.join(baseCommandsDir, module, 'workflows');
+      await fs.ensureDir(moduleWorkflowsDir);
+      const launcherPath = path.join(moduleWorkflowsDir, 'README.md');
+      await fs.writeFile(launcherPath, content);
+    }
+  }
+
+  groupWorkflowsByModule(workflows) {
+    const workflowsByModule = {};
+
+    for (const workflow of workflows) {
+      if (!workflowsByModule[workflow.module]) {
+        workflowsByModule[workflow.module] = [];
+      }
+
+      workflowsByModule[workflow.module].push({
+        ...workflow,
+        displayPath: this.transformWorkflowPath(workflow.path),
+      });
+    }
+
+    return workflowsByModule;
+  }
+
+  buildModuleWorkflowLaunchers(groupedWorkflows) {
+    const launchers = {};
+
+    for (const [module, moduleWorkflows] of Object.entries(groupedWorkflows)) {
+      launchers[module] = this.buildLauncherContent(module, moduleWorkflows);
+    }
+
+    return launchers;
+  }
+
+  buildLauncherContent(module, moduleWorkflows) {
+    let content = `# ${module.toUpperCase()} Workflows
+
+## Available Workflows in ${module}
+
+`;
+
+    for (const workflow of moduleWorkflows) {
+      content += `**${workflow.name}**\n`;
+      content += `- Path: \`${workflow.displayPath}\`\n`;
+      content += `- ${workflow.description}\n\n`;
+    }
+
+    content += `
+## Execution
+
+When running any workflow:
+1. LOAD {project-root}/${this.xiaomaFolderName}/core/tasks/workflow.xml
+2. Pass the workflow path as 'workflow-config' parameter
+3. Follow workflow.xml instructions EXACTLY
+4. Save outputs after EACH section
+
+## Modes
+- Normal: Full interaction
+- #yolo: Skip optional steps
+`;
+
+    return content;
+  }
+
+  transformWorkflowPath(workflowPath) {
+    let transformed = workflowPath;
+
+    if (workflowPath.includes('/src/modules/')) {
+      const match = workflowPath.match(/\/src\/modules\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/${this.xiaomaFolderName}/${match[1]}`;
+      }
+    } else if (workflowPath.includes('/src/core/')) {
+      const match = workflowPath.match(/\/src\/core\/(.+)/);
+      if (match) {
+        transformed = `{project-root}/${this.xiaomaFolderName}/core/${match[1]}`;
+      }
+    }
+
+    return transformed;
+  }
+
+  async loadWorkflowManifest(xiaomaDir) {
+    const manifestPath = path.join(xiaomaDir, '_cfg', 'workflow-manifest.csv');
+
+    if (!(await fs.pathExists(manifestPath))) {
+      return null;
+    }
+
+    const csvContent = await fs.readFile(manifestPath, 'utf8');
+    return csv.parse(csvContent, {
+      columns: true,
+      skip_empty_lines: true,
+    });
+  }
+}
+
+module.exports = { WorkflowCommandGenerator };

package/tools/cli/installers/lib/ide/shared/xiaoma-artifacts.js

@@ -0,0 +1,143 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+
+/**
+ * Helpers for gathering XIAOMA agents/tasks from the installed tree.
+ * Shared by installers that need Claude-style exports.
+ */
+async function getAgentsFromBmad(xiaomaDir, selectedModules = []) {
+  const agents = [];
+
+  // Get core agents
+  if (await fs.pathExists(path.join(xiaomaDir, 'core', 'agents'))) {
+    const coreAgents = await getAgentsFromDir(path.join(xiaomaDir, 'core', 'agents'), 'core');
+    agents.push(...coreAgents);
+  }
+
+  // Get module agents
+  for (const moduleName of selectedModules) {
+    const agentsPath = path.join(xiaomaDir, moduleName, 'agents');
+
+    if (await fs.pathExists(agentsPath)) {
+      const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
+      agents.push(...moduleAgents);
+    }
+  }
+
+  // Get standalone agents from xiaoma/agents/ directory
+  const standaloneAgentsDir = path.join(xiaomaDir, 'agents');
+  if (await fs.pathExists(standaloneAgentsDir)) {
+    const agentDirs = await fs.readdir(standaloneAgentsDir, { withFileTypes: true });
+
+    for (const agentDir of agentDirs) {
+      if (!agentDir.isDirectory()) continue;
+
+      const agentDirPath = path.join(standaloneAgentsDir, agentDir.name);
+      const agentFiles = await fs.readdir(agentDirPath);
+
+      for (const file of agentFiles) {
+        if (!file.endsWith('.md')) continue;
+        if (file.includes('.customize.')) continue;
+
+        const filePath = path.join(agentDirPath, file);
+        const content = await fs.readFile(filePath, 'utf8');
+
+        if (content.includes('localskip="true"')) continue;
+
+        agents.push({
+          path: filePath,
+          name: file.replace('.md', ''),
+          module: 'standalone', // Mark as standalone agent
+        });
+      }
+    }
+  }
+
+  return agents;
+}
+
+async function getTasksFromBmad(xiaomaDir, selectedModules = []) {
+  const tasks = [];
+
+  if (await fs.pathExists(path.join(xiaomaDir, 'core', 'tasks'))) {
+    const coreTasks = await getTasksFromDir(path.join(xiaomaDir, 'core', 'tasks'), 'core');
+    tasks.push(...coreTasks);
+  }
+
+  for (const moduleName of selectedModules) {
+    const tasksPath = path.join(xiaomaDir, moduleName, 'tasks');
+
+    if (await fs.pathExists(tasksPath)) {
+      const moduleTasks = await getTasksFromDir(tasksPath, moduleName);
+      tasks.push(...moduleTasks);
+    }
+  }
+
+  return tasks;
+}
+
+async function getAgentsFromDir(dirPath, moduleName) {
+  const agents = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return agents;
+  }
+
+  const files = await fs.readdir(dirPath);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) {
+      continue;
+    }
+
+    if (file.includes('.customize.')) {
+      continue;
+    }
+
+    const filePath = path.join(dirPath, file);
+    const content = await fs.readFile(filePath, 'utf8');
+
+    if (content.includes('localskip="true"')) {
+      continue;
+    }
+
+    agents.push({
+      path: filePath,
+      name: file.replace('.md', ''),
+      module: moduleName,
+    });
+  }
+
+  return agents;
+}
+
+async function getTasksFromDir(dirPath, moduleName) {
+  const tasks = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return tasks;
+  }
+
+  const files = await fs.readdir(dirPath);
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) {
+      continue;
+    }
+
+    tasks.push({
+      path: path.join(dirPath, file),
+      name: file.replace('.md', ''),
+      module: moduleName,
+    });
+  }
+
+  return tasks;
+}
+
+module.exports = {
+  getAgentsFromBmad,
+  getTasksFromBmad,
+  getAgentsFromDir,
+  getTasksFromDir,
+};

package/tools/cli/installers/lib/ide/templates/agent-command-template.md

@@ -0,0 +1,14 @@
+---
+name: '{{name}}'
+description: '{{description}}'
+---
+
+You must fully embody this agent's persona and follow all activation instructions exactly as specified. NEVER break character until given an exit command.
+
+<agent-activation CRITICAL="TRUE">
+1. LOAD the FULL agent file from @{xiaoma_folder}/{{module}}/agents/{{name}}.md
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. Execute ALL activation steps exactly as written in the agent file
+4. Follow the agent's persona and menu system precisely
+5. Stay in character throughout the session
+</agent-activation>

package/tools/cli/installers/lib/ide/templates/gemini-agent-command.toml

@@ -0,0 +1,14 @@
+description = "Activates the {{title}} agent from the BMad Method."
+prompt = """
+CRITICAL: You are now the BMad '{{title}}' agent.
+
+PRE-FLIGHT CHECKLIST:
+1.  [ ] IMMEDIATE ACTION: Load and parse @{{xiaoma_folder}}/{{module}}/config.yaml - store ALL config values in memory for use throughout the session.
+2.  [ ] IMMEDIATE ACTION: Read and internalize the full agent definition at @{{xiaoma_folder}}/{{module}}/agents/{{name}}.md.
+3.  [ ] CONFIRM: The user's name from config is {user_name}.
+
+Only after all checks are complete, greet the user by name and display the menu.
+Acknowledge this checklist is complete in your first response.
+
+AGENT DEFINITION: @{{xiaoma_folder}}/{{module}}/agents/{{name}}.md
+"""

package/tools/cli/installers/lib/ide/templates/gemini-task-command.toml

@@ -0,0 +1,12 @@
+description = "Executes the {{taskName}} task from the BMad Method."
+prompt = """
+Execute the following BMad Method task workflow:
+
+PRE-FLIGHT CHECKLIST:
+1.  [ ] IMMEDIATE ACTION: Load and parse @{{xiaoma_folder}}/{{module}}/config.yaml.
+2.  [ ] IMMEDIATE ACTION: Read and load the task definition at @{{xiaoma_folder}}/{{module}}/tasks/{{filename}}.
+
+Follow all instructions and complete the task as defined.
+
+TASK DEFINITION: @{{xiaoma_folder}}/{{module}}/tasks/{{filename}}
+"""

package/tools/cli/installers/lib/ide/templates/workflow-command-template.md

@@ -0,0 +1,13 @@
+---
+description: '{{description}}'
+---
+
+IT IS CRITICAL THAT YOU FOLLOW THESE STEPS - while staying in character as the current agent persona you may have loaded:
+
+<steps CRITICAL="TRUE">
+1. Always LOAD the FULL @{xiaoma_folder}/core/tasks/workflow.xml
+2. READ its entire contents - this is the CORE OS for EXECUTING the specific workflow-config @{{workflow_path}}
+3. Pass the yaml path {{workflow_path}} as 'workflow-config' parameter to the workflow.xml instructions
+4. Follow workflow.xml instructions EXACTLY as written to process and follow the specific workflow config and its instructions
+5. Save outputs after EACH section when generating any documents from templates
+</steps>