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

package/tools/cli/installers/lib/ide/crush.js

@@ -0,0 +1,287 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * Crush IDE setup handler
+ * Creates commands in .crush/commands/ directory structure
+ */
+class CrushSetup extends BaseIdeSetup {
+  constructor() {
+    super('crush', 'Crush');
+    this.configDir = '.crush';
+    this.commandsDir = 'commands';
+  }
+
+  /**
+   * Setup Crush IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, xiaomaDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Create .crush/commands/xiaoma directory structure
+    const crushDir = path.join(projectDir, this.configDir);
+    const commandsDir = path.join(crushDir, this.commandsDir, 'xiaoma');
+
+    await this.ensureDir(commandsDir);
+
+    // Generate agent launchers
+    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, options.selectedModules || []);
+
+    // Get tasks, tools, and workflows (standalone only)
+    const tasks = await this.getTasks(xiaomaDir, true);
+    const tools = await this.getTools(xiaomaDir, true);
+    const workflows = await this.getWorkflows(xiaomaDir, true);
+
+    // Organize by module
+    const agentCount = await this.organizeByModule(commandsDir, agentArtifacts, tasks, tools, workflows, projectDir);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount.agents} agent commands created`));
+    console.log(chalk.dim(`  - ${agentCount.tasks} task commands created`));
+    console.log(chalk.dim(`  - ${agentCount.tools} tool commands created`));
+    console.log(chalk.dim(`  - ${agentCount.workflows} workflow commands created`));
+    console.log(chalk.dim(`  - Commands directory: ${path.relative(projectDir, commandsDir)}`));
+    console.log(chalk.dim('\n  Commands can be accessed via Crush command palette'));
+
+    return {
+      success: true,
+      ...agentCount,
+    };
+  }
+
+  /**
+   * Organize commands by module
+   */
+  async organizeByModule(commandsDir, agentArtifacts, tasks, tools, workflows, projectDir) {
+    // Get unique modules
+    const modules = new Set();
+    for (const artifact of agentArtifacts) modules.add(artifact.module);
+    for (const task of tasks) modules.add(task.module);
+    for (const tool of tools) modules.add(tool.module);
+    for (const workflow of workflows) modules.add(workflow.module);
+
+    let agentCount = 0;
+    let taskCount = 0;
+    let toolCount = 0;
+    let workflowCount = 0;
+
+    // Create module directories
+    for (const module of modules) {
+      const moduleDir = path.join(commandsDir, module);
+      const moduleAgentsDir = path.join(moduleDir, 'agents');
+      const moduleTasksDir = path.join(moduleDir, 'tasks');
+      const moduleToolsDir = path.join(moduleDir, 'tools');
+      const moduleWorkflowsDir = path.join(moduleDir, 'workflows');
+
+      await this.ensureDir(moduleAgentsDir);
+      await this.ensureDir(moduleTasksDir);
+      await this.ensureDir(moduleToolsDir);
+      await this.ensureDir(moduleWorkflowsDir);
+
+      // Write module-specific agent launchers
+      const moduleAgents = agentArtifacts.filter((a) => a.module === module);
+      for (const artifact of moduleAgents) {
+        const targetPath = path.join(moduleAgentsDir, `${artifact.name}.md`);
+        await this.writeFile(targetPath, artifact.content);
+        agentCount++;
+      }
+
+      // Copy module-specific tasks
+      const moduleTasks = tasks.filter((t) => t.module === module);
+      for (const task of moduleTasks) {
+        const content = await this.readFile(task.path);
+        const commandContent = this.createTaskCommand(task, content);
+        const targetPath = path.join(moduleTasksDir, `${task.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        taskCount++;
+      }
+
+      // Copy module-specific tools
+      const moduleTools = tools.filter((t) => t.module === module);
+      for (const tool of moduleTools) {
+        const content = await this.readFile(tool.path);
+        const commandContent = this.createToolCommand(tool, content);
+        const targetPath = path.join(moduleToolsDir, `${tool.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        toolCount++;
+      }
+
+      // Copy module-specific workflows
+      const moduleWorkflows = workflows.filter((w) => w.module === module);
+      for (const workflow of moduleWorkflows) {
+        const content = await this.readFile(workflow.path);
+        const commandContent = this.createWorkflowCommand(workflow, content);
+        const targetPath = path.join(moduleWorkflowsDir, `${workflow.name}.md`);
+        await this.writeFile(targetPath, commandContent);
+        workflowCount++;
+      }
+    }
+
+    return {
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Create task command content
+   */
+  createTaskCommand(task, content) {
+    // Extract task name
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const taskName = nameMatch ? nameMatch[1] : this.formatTitle(task.name);
+
+    let commandContent = `# /task-${task.name} Command
+
+When this command is used, execute the following task:
+
+## ${taskName} Task
+
+${content}
+
+## Command Usage
+
+This command executes the ${taskName} task from the XIAOMA ${task.module.toUpperCase()} module.
+
+## Module
+
+Part of the XIAOMA ${task.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Create tool command content
+   */
+  createToolCommand(tool, content) {
+    // Extract tool name
+    const nameMatch = content.match(/name="([^"]+)"/);
+    const toolName = nameMatch ? nameMatch[1] : this.formatTitle(tool.name);
+
+    let commandContent = `# /tool-${tool.name} Command
+
+When this command is used, execute the following tool:
+
+## ${toolName} Tool
+
+${content}
+
+## Command Usage
+
+This command executes the ${toolName} tool from the XIAOMA ${tool.module.toUpperCase()} module.
+
+## Module
+
+Part of the XIAOMA ${tool.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Create workflow command content
+   */
+  createWorkflowCommand(workflow, content) {
+    const workflowName = workflow.name ? this.formatTitle(workflow.name) : 'Workflow';
+
+    let commandContent = `# /${workflow.name} Command
+
+When this command is used, execute the following workflow:
+
+## ${workflowName} Workflow
+
+${content}
+
+## Command Usage
+
+This command executes the ${workflowName} workflow from the XIAOMA ${workflow.module.toUpperCase()} module.
+
+## Module
+
+Part of the XIAOMA ${workflow.module.toUpperCase()} module.
+`;
+
+    return commandContent;
+  }
+
+  /**
+   * Format name as title
+   */
+  formatTitle(name) {
+    return name
+      .split('-')
+      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+      .join(' ');
+  }
+
+  /**
+   * Cleanup Crush configuration
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const xiaomaCommandsDir = path.join(projectDir, this.configDir, this.commandsDir, 'xiaoma');
+
+    if (await fs.pathExists(xiaomaCommandsDir)) {
+      await fs.remove(xiaomaCommandsDir);
+      console.log(chalk.dim(`Removed XIAOMA commands from Crush`));
+    }
+  }
+
+  /**
+   * Install a custom agent launcher for Crush
+   * @param {string} projectDir - Project directory
+   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
+   * @param {string} agentPath - Path to compiled agent (relative to project root)
+   * @param {Object} metadata - Agent metadata
+   * @returns {Object} Installation result
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    const crushDir = path.join(projectDir, this.configDir);
+    const xiaomaCommandsDir = path.join(crushDir, this.commandsDir, 'xiaoma');
+
+    // Create .crush/commands/xiaoma directory if it doesn't exist
+    await fs.ensureDir(xiaomaCommandsDir);
+
+    // Create custom agent launcher
+    const launcherContent = `# ${agentName} Custom Agent
+
+**⚠️ IMPORTANT**: Run @${agentPath} first to load the complete agent!
+
+This is a launcher for the custom XIAOMA agent "${agentName}".
+
+## Usage
+1. First run: \`${agentPath}\` to load the complete agent
+2. Then use this command to activate ${agentName}
+
+The agent will follow the persona and instructions from the main agent file.
+
+---
+
+*Generated by XIAOMA Method*`;
+
+    const fileName = `custom-${agentName.toLowerCase()}.md`;
+    const launcherPath = path.join(xiaomaCommandsDir, fileName);
+
+    // Write the launcher file
+    await fs.writeFile(launcherPath, launcherContent, 'utf8');
+
+    return {
+      ide: 'crush',
+      path: path.relative(projectDir, launcherPath),
+      command: agentName,
+      type: 'custom-agent-launcher',
+    };
+  }
+}
+
+module.exports = { CrushSetup };

package/tools/cli/installers/lib/ide/cursor.js

@@ -0,0 +1,400 @@
+const path = require('node:path');
+const { BaseIdeSetup } = require('./_base-ide');
+const chalk = require('chalk');
+const { AgentCommandGenerator } = require('./shared/agent-command-generator');
+
+/**
+ * Cursor IDE setup handler
+ */
+class CursorSetup extends BaseIdeSetup {
+  constructor() {
+    super('cursor', 'Cursor', true); // preferred IDE
+    this.configDir = '.cursor';
+    this.rulesDir = 'rules';
+  }
+
+  /**
+   * Cleanup old XIAOMA installation before reinstalling
+   * @param {string} projectDir - Project directory
+   */
+  async cleanup(projectDir) {
+    const fs = require('fs-extra');
+    const xiaomaRulesDir = path.join(projectDir, this.configDir, this.rulesDir, 'xiaoma');
+
+    if (await fs.pathExists(xiaomaRulesDir)) {
+      await fs.remove(xiaomaRulesDir);
+      console.log(chalk.dim(`  Removed old XIAOMA rules from ${this.name}`));
+    }
+  }
+
+  /**
+   * Setup Cursor IDE configuration
+   * @param {string} projectDir - Project directory
+   * @param {string} xiaomaDir - XIAOMA installation directory
+   * @param {Object} options - Setup options
+   */
+  async setup(projectDir, xiaomaDir, options = {}) {
+    console.log(chalk.cyan(`Setting up ${this.name}...`));
+
+    // Clean up old XIAOMA installation first
+    await this.cleanup(projectDir);
+
+    // Create .cursor/rules directory structure
+    const cursorDir = path.join(projectDir, this.configDir);
+    const rulesDir = path.join(cursorDir, this.rulesDir);
+    const xiaomaRulesDir = path.join(rulesDir, 'xiaoma');
+
+    await this.ensureDir(xiaomaRulesDir);
+
+    // Generate agent launchers first
+    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
+    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, options.selectedModules || []);
+
+    // Convert artifacts to agent format for index creation
+    const agents = agentArtifacts.map((a) => ({ module: a.module, name: a.name }));
+
+    // Get tasks, tools, and workflows (standalone only)
+    const tasks = await this.getTasks(xiaomaDir, true);
+    const tools = await this.getTools(xiaomaDir, true);
+    const workflows = await this.getWorkflows(xiaomaDir, true);
+
+    // Create directories for each module
+    const modules = new Set();
+    for (const item of [...agents, ...tasks, ...tools, ...workflows]) modules.add(item.module);
+
+    for (const module of modules) {
+      await this.ensureDir(path.join(xiaomaRulesDir, module));
+      await this.ensureDir(path.join(xiaomaRulesDir, module, 'agents'));
+      await this.ensureDir(path.join(xiaomaRulesDir, module, 'tasks'));
+      await this.ensureDir(path.join(xiaomaRulesDir, module, 'tools'));
+      await this.ensureDir(path.join(xiaomaRulesDir, module, 'workflows'));
+    }
+
+    // Process and write agent launchers with MDC format
+    let agentCount = 0;
+    for (const artifact of agentArtifacts) {
+      // Add MDC metadata header to launcher (but don't call processContent which adds activation headers)
+      const content = this.wrapLauncherWithMDC(artifact.content, {
+        module: artifact.module,
+        name: artifact.name,
+      });
+
+      const targetPath = path.join(xiaomaRulesDir, artifact.module, 'agents', `${artifact.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      agentCount++;
+    }
+
+    // Process and copy tasks
+    let taskCount = 0;
+    for (const task of tasks) {
+      const content = await this.readAndProcess(task.path, {
+        module: task.module,
+        name: task.name,
+      });
+
+      const targetPath = path.join(xiaomaRulesDir, task.module, 'tasks', `${task.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      taskCount++;
+    }
+
+    // Process and copy tools
+    let toolCount = 0;
+    for (const tool of tools) {
+      const content = await this.readAndProcess(tool.path, {
+        module: tool.module,
+        name: tool.name,
+      });
+
+      const targetPath = path.join(xiaomaRulesDir, tool.module, 'tools', `${tool.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      toolCount++;
+    }
+
+    // Process and copy workflows
+    let workflowCount = 0;
+    for (const workflow of workflows) {
+      const content = await this.readAndProcess(workflow.path, {
+        module: workflow.module,
+        name: workflow.name,
+      });
+
+      const targetPath = path.join(xiaomaRulesDir, workflow.module, 'workflows', `${workflow.name}.mdc`);
+
+      await this.writeFile(targetPath, content);
+      workflowCount++;
+    }
+
+    // Create XIAOMA index file (but NOT .cursorrules - user manages that)
+    await this.createXIAOMAIndex(xiaomaRulesDir, agents, tasks, tools, workflows, modules);
+
+    console.log(chalk.green(`✓ ${this.name} configured:`));
+    console.log(chalk.dim(`  - ${agentCount} agents installed`));
+    console.log(chalk.dim(`  - ${taskCount} tasks installed`));
+    console.log(chalk.dim(`  - ${toolCount} tools installed`));
+    console.log(chalk.dim(`  - ${workflowCount} workflows installed`));
+    console.log(chalk.dim(`  - Rules directory: ${path.relative(projectDir, xiaomaRulesDir)}`));
+
+    return {
+      success: true,
+      agents: agentCount,
+      tasks: taskCount,
+      tools: toolCount,
+      workflows: workflowCount,
+    };
+  }
+
+  /**
+   * Create XIAOMA index file for easy navigation
+   */
+  async createXIAOMAIndex(xiaomaRulesDir, agents, tasks, tools, workflows, modules) {
+    const indexPath = path.join(xiaomaRulesDir, 'index.mdc');
+
+    let content = `---
+description: XIAOMA Method - Master Index
+globs:
+alwaysApply: true
+---
+
+# XIAOMA Method - Cursor Rules Index
+
+This is the master index for all XIAOMA agents, tasks, tools, and workflows available in your project.
+
+## Installation Complete!
+
+XIAOMA rules have been installed to: \`.cursor/rules/xiaoma/\`
+
+**Note:** XIAOMA does not modify your \`.cursorrules\` file. You manage that separately.
+
+## How to Use
+
+- Reference specific agents: @xiaoma/{module}/agents/{agent-name}
+- Reference specific tasks: @xiaoma/{module}/tasks/{task-name}
+- Reference specific tools: @xiaoma/{module}/tools/{tool-name}
+- Reference specific workflows: @xiaoma/{module}/workflows/{workflow-name}
+- Reference entire modules: @xiaoma/{module}
+- Reference this index: @xiaoma/index
+
+## Available Modules
+
+`;
+
+    for (const module of modules) {
+      content += `### ${module.toUpperCase()}\n\n`;
+
+      // List agents for this module
+      const moduleAgents = agents.filter((a) => a.module === module);
+      if (moduleAgents.length > 0) {
+        content += `**Agents:**\n`;
+        for (const agent of moduleAgents) {
+          content += `- @xiaoma/${module}/agents/${agent.name} - ${agent.name}\n`;
+        }
+        content += '\n';
+      }
+
+      // List tasks for this module
+      const moduleTasks = tasks.filter((t) => t.module === module);
+      if (moduleTasks.length > 0) {
+        content += `**Tasks:**\n`;
+        for (const task of moduleTasks) {
+          content += `- @xiaoma/${module}/tasks/${task.name} - ${task.name}\n`;
+        }
+        content += '\n';
+      }
+
+      // List tools for this module
+      const moduleTools = tools.filter((t) => t.module === module);
+      if (moduleTools.length > 0) {
+        content += `**Tools:**\n`;
+        for (const tool of moduleTools) {
+          content += `- @xiaoma/${module}/tools/${tool.name} - ${tool.name}\n`;
+        }
+        content += '\n';
+      }
+
+      // List workflows for this module
+      const moduleWorkflows = workflows.filter((w) => w.module === module);
+      if (moduleWorkflows.length > 0) {
+        content += `**Workflows:**\n`;
+        for (const workflow of moduleWorkflows) {
+          content += `- @xiaoma/${module}/workflows/${workflow.name} - ${workflow.name}\n`;
+        }
+        content += '\n';
+      }
+    }
+
+    content += `
+## Quick Reference
+
+- All XIAOMA rules are Manual type - reference them explicitly when needed
+- Agents provide persona-based assistance with specific expertise
+- Tasks are reusable workflows for common operations
+- Tools provide specialized functionality
+- Workflows orchestrate multi-step processes
+- Each agent includes an activation block for proper initialization
+
+## Configuration
+
+XIAOMA rules are configured as Manual rules (alwaysApply: false) to give you control
+over when they're included in your context. Reference them explicitly when you need
+specific agent expertise, task workflows, tools, or guided workflows.
+`;
+
+    await this.writeFile(indexPath, content);
+  }
+
+  /**
+   * Read and process file content
+   */
+  async readAndProcess(filePath, metadata) {
+    const fs = require('fs-extra');
+    const content = await fs.readFile(filePath, 'utf8');
+    return this.processContent(content, metadata);
+  }
+
+  /**
+   * Override processContent to add MDC metadata header for Cursor
+   * @param {string} content - File content
+   * @param {Object} metadata - File metadata
+   * @returns {string} Processed content with MDC header
+   */
+  processContent(content, metadata = {}) {
+    // First apply base processing (includes activation injection for agents)
+    let processed = super.processContent(content, metadata);
+
+    // Strip any existing frontmatter from the processed content
+    // This prevents duplicate frontmatter blocks
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    if (frontmatterRegex.test(processed)) {
+      processed = processed.replace(frontmatterRegex, '');
+    }
+
+    // Determine the type and description based on content
+    const isAgent = content.includes('<agent');
+    const isTask = content.includes('<task');
+    const isTool = content.includes('<tool');
+    const isWorkflow = content.includes('workflow:') || content.includes('name:');
+
+    let description = '';
+    let globs = '';
+
+    if (isAgent) {
+      // Extract agent title if available
+      const titleMatch = content.match(/title="([^"]+)"/);
+      const title = titleMatch ? titleMatch[1] : metadata.name;
+      description = `XIAOMA ${metadata.module.toUpperCase()} Agent: ${title}`;
+      globs = '';
+    } else if (isTask) {
+      // Extract task name if available
+      const nameMatch = content.match(/name="([^"]+)"/);
+      const taskName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `XIAOMA ${metadata.module.toUpperCase()} Task: ${taskName}`;
+      globs = '';
+    } else if (isTool) {
+      // Extract tool name if available
+      const nameMatch = content.match(/name="([^"]+)"/);
+      const toolName = nameMatch ? nameMatch[1] : metadata.name;
+      description = `XIAOMA ${metadata.module.toUpperCase()} Tool: ${toolName}`;
+      globs = '';
+    } else if (isWorkflow) {
+      // Workflow
+      description = `XIAOMA ${metadata.module.toUpperCase()} Workflow: ${metadata.name}`;
+      globs = '';
+    } else {
+      description = `XIAOMA ${metadata.module.toUpperCase()}: ${metadata.name}`;
+      globs = '';
+    }
+
+    // Create MDC metadata header
+    const mdcHeader = `---
+description: ${description}
+globs: ${globs}
+alwaysApply: false
+---
+
+`;
+
+    // Add the MDC header to the processed content
+    return mdcHeader + processed;
+  }
+
+  /**
+   * Wrap launcher content with MDC metadata (without base processing)
+   * Launchers are already complete and should not have activation headers injected
+   */
+  wrapLauncherWithMDC(launcherContent, metadata = {}) {
+    // Strip the launcher's frontmatter - we'll replace it with MDC frontmatter
+    const frontmatterRegex = /^---\s*\n[\s\S]*?\n---\s*\n/;
+    const contentWithoutFrontmatter = launcherContent.replace(frontmatterRegex, '');
+
+    // Extract metadata from launcher frontmatter for MDC description
+    const nameMatch = launcherContent.match(/name:\s*"([^"]+)"/);
+    const name = nameMatch ? nameMatch[1] : metadata.name;
+
+    const description = `XIAOMA ${metadata.module.toUpperCase()} Agent: ${name}`;
+
+    // Create MDC metadata header
+    const mdcHeader = `---
+description: ${description}
+globs:
+alwaysApply: false
+---
+
+`;
+
+    // Return MDC header + launcher content (without its original frontmatter)
+    return mdcHeader + contentWithoutFrontmatter;
+  }
+
+  /**
+   * Install a custom agent launcher for Cursor
+   * @param {string} projectDir - Project directory
+   * @param {string} agentName - Agent name (e.g., "fred-commit-poet")
+   * @param {string} agentPath - Path to compiled agent (relative to project root)
+   * @param {Object} metadata - Agent metadata
+   * @returns {Object|null} Info about created command
+   */
+  async installCustomAgentLauncher(projectDir, agentName, agentPath, metadata) {
+    const customAgentsDir = path.join(projectDir, this.configDir, this.rulesDir, 'xiaoma', 'custom', 'agents');
+
+    if (!(await this.exists(path.join(projectDir, this.configDir)))) {
+      return null; // IDE not configured for this project
+    }
+
+    await this.ensureDir(customAgentsDir);
+
+    const launcherContent = `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 @${agentPath}
+2. READ its entire contents - this contains the complete agent persona, menu, and instructions
+3. FOLLOW every step in the <activation> section precisely
+4. DISPLAY the welcome/greeting as instructed
+5. PRESENT the numbered menu
+6. WAIT for user input before proceeding
+</agent-activation>
+`;
+
+    // Cursor uses MDC format with metadata header
+    const mdcContent = `---
+description: "${agentName} agent"
+globs:
+alwaysApply: false
+---
+
+${launcherContent}
+`;
+
+    const launcherPath = path.join(customAgentsDir, `${agentName}.mdc`);
+    await this.writeFile(launcherPath, mdcContent);
+
+    return {
+      path: launcherPath,
+      command: `@${agentName}`,
+    };
+  }
+}
+
+module.exports = { CursorSetup };