@zeyue0329/xiaoma-cli 1.6.4 → 1.7.0

package/tools/cli/installers/lib/ide/github-copilot.js

@@ -1,699 +0,0 @@
-const path = require('node:path');
-const { BaseIdeSetup } = require('./_base-ide');
-const prompts = require('../../../lib/prompts');
-const { AgentCommandGenerator } = require('./shared/agent-command-generator');
-const { XIAOMA_FOLDER_NAME, toDashPath } = require('./shared/path-utils');
-const fs = require('fs-extra');
-const csv = require('csv-parse/sync');
-const yaml = require('yaml');
-
-/**
- * GitHub Copilot setup handler
- * Creates agents in .github/agents/, prompts in .github/prompts/,
- * copilot-instructions.md, and configures VS Code settings
- */
-class GitHubCopilotSetup extends BaseIdeSetup {
-  constructor() {
-    super('github-copilot', 'GitHub Copilot', false);
-    // Don't set configDir to '.github' — nearly every GitHub repo has that directory,
-    // which would cause the base detect() to false-positive. Use detectionPaths instead.
-    this.configDir = null;
-    this.githubDir = '.github';
-    this.agentsDir = 'agents';
-    this.promptsDir = 'prompts';
-    this.detectionPaths = ['.github/copilot-instructions.md', '.github/agents'];
-  }
-
-  /**
-   * Setup GitHub Copilot configuration
-   * @param {string} projectDir - Project directory
-   * @param {string} xiaomaDir - XIAOMA installation directory
-   * @param {Object} options - Setup options
-   */
-  async setup(projectDir, xiaomaDir, options = {}) {
-    if (!options.silent) await prompts.log.info(`Setting up ${this.name}...`);
-
-    // Create .github/agents and .github/prompts directories
-    const githubDir = path.join(projectDir, this.githubDir);
-    const agentsDir = path.join(githubDir, this.agentsDir);
-    const promptsDir = path.join(githubDir, this.promptsDir);
-    await this.ensureDir(agentsDir);
-    await this.ensureDir(promptsDir);
-
-    // Preserve any customised tool permissions from existing files before cleanup
-    this.existingToolPermissions = await this.collectExistingToolPermissions(projectDir);
-
-    // Clean up any existing XIAOMA files before reinstalling
-    await this.cleanup(projectDir);
-
-    // Load agent manifest for enriched descriptions
-    const agentManifest = await this.loadAgentManifest(xiaomaDir);
-
-    // Generate agent launchers
-    const agentGen = new AgentCommandGenerator(this.xiaomaFolderName);
-    const { artifacts: agentArtifacts } = await agentGen.collectAgentArtifacts(xiaomaDir, options.selectedModules || []);
-
-    // Create agent .agent.md files
-    let agentCount = 0;
-    for (const artifact of agentArtifacts) {
-      const agentMeta = agentManifest.get(artifact.name);
-
-      // Compute fileName first so we can look up any existing tool permissions
-      const dashName = toDashPath(artifact.relativePath);
-      const fileName = dashName.replace(/\.md$/, '.agent.md');
-      const toolsStr = this.getToolsForFile(fileName);
-      const agentContent = this.createAgentContent(artifact, agentMeta, toolsStr);
-      const targetPath = path.join(agentsDir, fileName);
-      await this.writeFile(targetPath, agentContent);
-      agentCount++;
-    }
-
-    // Generate prompt files from xiaoma-help.csv
-    const promptCount = await this.generatePromptFiles(projectDir, xiaomaDir, agentArtifacts, agentManifest);
-
-    // Generate copilot-instructions.md
-    await this.generateCopilotInstructions(projectDir, xiaomaDir, agentManifest, options);
-
-    if (!options.silent) await prompts.log.success(`${this.name} configured: ${agentCount} agents, ${promptCount} prompts → .github/`);
-
-    return {
-      success: true,
-      results: {
-        agents: agentCount,
-        workflows: promptCount,
-        tasks: 0,
-        tools: 0,
-      },
-    };
-  }
-
-  /**
-   * Load agent manifest CSV into a Map keyed by agent name
-   * @param {string} xiaomaDir - XIAOMA installation directory
-   * @returns {Map} Agent metadata keyed by name
-   */
-  async loadAgentManifest(xiaomaDir) {
-    const manifestPath = path.join(xiaomaDir, '_config', 'agent-manifest.csv');
-    const agents = new Map();
-
-    if (!(await fs.pathExists(manifestPath))) {
-      return agents;
-    }
-
-    try {
-      const csvContent = await fs.readFile(manifestPath, 'utf8');
-      const records = csv.parse(csvContent, {
-        columns: true,
-        skip_empty_lines: true,
-      });
-
-      for (const record of records) {
-        agents.set(record.name, record);
-      }
-    } catch {
-      // Gracefully degrade if manifest is unreadable/malformed
-    }
-
-    return agents;
-  }
-
-  /**
-   * Load xiaoma-help.csv to drive prompt generation
-   * @param {string} xiaomaDir - XIAOMA installation directory
-   * @returns {Array|null} Parsed CSV rows
-   */
-  async loadXiaomaHelp(xiaomaDir) {
-    const helpPath = path.join(xiaomaDir, '_config', 'xiaoma-help.csv');
-
-    if (!(await fs.pathExists(helpPath))) {
-      return null;
-    }
-
-    try {
-      const csvContent = await fs.readFile(helpPath, 'utf8');
-      return csv.parse(csvContent, {
-        columns: true,
-        skip_empty_lines: true,
-      });
-    } catch {
-      // Gracefully degrade if help CSV is unreadable/malformed
-      return null;
-    }
-  }
-
-  /**
-   * Create agent .agent.md content with enriched description
-   * @param {Object} artifact - Agent artifact from AgentCommandGenerator
-   * @param {Object|undefined} manifestEntry - Agent manifest entry with metadata
-   * @returns {string} Agent file content
-   */
-  createAgentContent(artifact, manifestEntry, toolsStr) {
-    // Build enriched description from manifest metadata
-    let description;
-    if (manifestEntry) {
-      const persona = manifestEntry.displayName || artifact.name;
-      const title = manifestEntry.title || this.formatTitle(artifact.name);
-      const capabilities = manifestEntry.capabilities || 'agent capabilities';
-      description = `${persona} — ${title}: ${capabilities}`;
-    } else {
-      description = `Activates the ${this.formatTitle(artifact.name)} agent persona.`;
-    }
-
-    // Build the agent file path for the activation block
-    const agentPath = artifact.agentPath || artifact.relativePath;
-    const agentFilePath = `{project-root}/${this.xiaomaFolderName}/${agentPath}`;
-
-    return `---
-description: '${description.replaceAll("'", "''")}'
-tools: ${toolsStr}
----
-
-You must fully embody this agent's persona and follow all activation instructions exactly as specified.
-
-<agent-activation CRITICAL="TRUE">
-1. LOAD the FULL agent file from ${agentFilePath}
-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>
-`;
-  }
-
-  /**
-   * Generate .prompt.md files for workflows, tasks, tech-writer commands, and agent activators
-   * @param {string} projectDir - Project directory
-   * @param {string} xiaomaDir - XIAOMA installation directory
-   * @param {Array} agentArtifacts - Agent artifacts for activator generation
-   * @param {Map} agentManifest - Agent manifest data
-   * @returns {number} Count of prompts generated
-   */
-  async generatePromptFiles(projectDir, xiaomaDir, agentArtifacts, agentManifest) {
-    const promptsDir = path.join(projectDir, this.githubDir, this.promptsDir);
-    let promptCount = 0;
-
-    // Load xiaoma-help.csv to drive workflow/task prompt generation
-    const helpEntries = await this.loadXiaomaHelp(xiaomaDir);
-
-    if (helpEntries) {
-      for (const entry of helpEntries) {
-        const command = entry.command;
-        if (!command) continue; // Skip entries without a command (tech-writer commands have no command column)
-
-        const workflowFile = entry['workflow-file'];
-        if (!workflowFile) continue; // Skip entries with no workflow file path
-        const promptFileName = `${command}.prompt.md`;
-        const toolsStr = this.getToolsForFile(promptFileName);
-        const promptContent = this.createWorkflowPromptContent(entry, workflowFile, toolsStr);
-        const promptPath = path.join(promptsDir, promptFileName);
-        await this.writeFile(promptPath, promptContent);
-        promptCount++;
-      }
-
-      // Generate tech-writer command prompts (entries with no command column)
-      for (const entry of helpEntries) {
-        if (entry.command) continue; // Already handled above
-        const techWriterPrompt = this.createTechWriterPromptContent(entry);
-        if (techWriterPrompt) {
-          const promptFileName = `${techWriterPrompt.fileName}.prompt.md`;
-          const promptPath = path.join(promptsDir, promptFileName);
-          await this.writeFile(promptPath, techWriterPrompt.content);
-          promptCount++;
-        }
-      }
-    }
-
-    // Generate agent activator prompts (Pattern D)
-    for (const artifact of agentArtifacts) {
-      const agentMeta = agentManifest.get(artifact.name);
-      const fileName = `xiaoma-${artifact.name}.prompt.md`;
-      const toolsStr = this.getToolsForFile(fileName);
-      const promptContent = this.createAgentActivatorPromptContent(artifact, agentMeta, toolsStr);
-      const promptPath = path.join(promptsDir, fileName);
-      await this.writeFile(promptPath, promptContent);
-      promptCount++;
-    }
-
-    return promptCount;
-  }
-
-  /**
-   * Create prompt content for a workflow/task entry from xiaoma-help.csv
-   * Determines the pattern (A, B, or A for .xml tasks) based on file extension
-   * @param {Object} entry - xiaoma-help.csv row
-   * @param {string} workflowFile - Workflow file path
-   * @returns {string} Prompt file content
-   */
-  createWorkflowPromptContent(entry, workflowFile, toolsStr) {
-    const description = this.escapeYamlSingleQuote(this.createPromptDescription(entry.name));
-    // xmc/config.yaml is safe to hardcode here: these prompts are only generated when
-    // xiaoma-help.csv exists (xmc module data), so xmc is guaranteed to be installed.
-    const configLine = `1. Load {project-root}/${this.xiaomaFolderName}/xmc/config.yaml and store ALL fields as session variables`;
-
-    let body;
-    if (workflowFile.endsWith('.yaml')) {
-      // Pattern B: YAML-based workflows — use workflow engine
-      body = `${configLine}
-2. Load the workflow engine at {project-root}/${this.xiaomaFolderName}/core/tasks/workflow.xml
-3. Load and execute the workflow configuration at {project-root}/${workflowFile} using the engine from step 2`;
-    } else if (workflowFile.endsWith('.xml')) {
-      // Pattern A variant: XML tasks — load and execute directly
-      body = `${configLine}
-2. Load and execute the task at {project-root}/${workflowFile}`;
-    } else {
-      // Pattern A: MD workflows — load and follow directly
-      body = `${configLine}
-2. Load and follow the workflow at {project-root}/${workflowFile}`;
-    }
-
-    return `---
-description: '${description}'
-agent: 'agent'
-tools: ${toolsStr}
----
-
-${body}
-`;
-  }
-
-  /**
-   * Create a short 2-5 word description for a prompt from the entry name
-   * @param {string} name - Entry name from xiaoma-help.csv
-   * @returns {string} Short description
-   */
-  createPromptDescription(name) {
-    const descriptionMap = {
-      'Brainstorm Project': 'Brainstorm ideas',
-      'Market Research': 'Market research',
-      'Domain Research': 'Domain research',
-      'Technical Research': 'Technical research',
-      'Create Brief': 'Create product brief',
-      'Create PRD': 'Create PRD',
-      'Validate PRD': 'Validate PRD',
-      'Edit PRD': 'Edit PRD',
-      'Create UX': 'Create UX design',
-      'Create Architecture': 'Create architecture',
-      'Create Epics and Stories': 'Create epics and stories',
-      'Check Implementation Readiness': 'Check implementation readiness',
-      'Sprint Planning': 'Sprint planning',
-      'Sprint Status': 'Sprint status',
-      'Create Story': 'Create story',
-      'Validate Story': 'Validate story',
-      'Dev Story': 'Dev story',
-      'QA Automation Test': 'QA automation',
-      'Code Review': 'Code review',
-      Retrospective: 'Retrospective',
-      'Document Project': 'Document project',
-      'Generate Project Context': 'Generate project context',
-      'Quick Spec': 'Quick spec',
-      'Quick Dev': 'Quick dev',
-      'Correct Course': 'Correct course',
-      Brainstorming: 'Brainstorm ideas',
-      'Party Mode': 'Party mode',
-      'xiaoma-help': 'XIAOMA help',
-      'Index Docs': 'Index documents',
-      'Shard Document': 'Shard document',
-      'Editorial Review - Prose': 'Editorial review prose',
-      'Editorial Review - Structure': 'Editorial review structure',
-      'Adversarial Review (General)': 'Adversarial review',
-    };
-
-    return descriptionMap[name] || name;
-  }
-
-  /**
-   * Create prompt content for tech-writer agent-only commands (Pattern C)
-   * @param {Object} entry - xiaoma-help.csv row
-   * @returns {Object|null} { fileName, content } or null if not a tech-writer command
-   */
-  createTechWriterPromptContent(entry) {
-    if (entry['agent-name'] !== 'tech-writer') return null;
-
-    const techWriterCommands = {
-      'Write Document': { code: 'WD', file: 'xiaoma-xmc-write-document', description: 'Write document' },
-      'Update Standards': { code: 'US', file: 'xiaoma-xmc-update-standards', description: 'Update standards' },
-      'Mermaid Generate': { code: 'MG', file: 'xiaoma-xmc-mermaid-generate', description: 'Mermaid generate' },
-      'Validate Document': { code: 'VD', file: 'xiaoma-xmc-validate-document', description: 'Validate document' },
-      'Explain Concept': { code: 'EC', file: 'xiaoma-xmc-explain-concept', description: 'Explain concept' },
-    };
-
-    const cmd = techWriterCommands[entry.name];
-    if (!cmd) return null;
-
-    const safeDescription = this.escapeYamlSingleQuote(cmd.description);
-    const toolsStr = this.getToolsForFile(`${cmd.file}.prompt.md`);
-
-    const content = `---
-description: '${safeDescription}'
-agent: 'agent'
-tools: ${toolsStr}
----
-
-1. Load {project-root}/${this.xiaomaFolderName}/xmc/config.yaml and store ALL fields as session variables
-2. Load the full agent file from {project-root}/${this.xiaomaFolderName}/xmc/agents/tech-writer/tech-writer.md and activate the Paige (Technical Writer) persona
-3. Execute the ${entry.name} menu command (${cmd.code})
-`;
-
-    return { fileName: cmd.file, content };
-  }
-
-  /**
-   * Create agent activator prompt content (Pattern D)
-   * @param {Object} artifact - Agent artifact
-   * @param {Object|undefined} manifestEntry - Agent manifest entry
-   * @returns {string} Prompt file content
-   */
-  createAgentActivatorPromptContent(artifact, manifestEntry, toolsStr) {
-    let description;
-    if (manifestEntry) {
-      description = manifestEntry.title || this.formatTitle(artifact.name);
-    } else {
-      description = this.formatTitle(artifact.name);
-    }
-
-    const safeDescription = this.escapeYamlSingleQuote(description);
-    const agentPath = artifact.agentPath || artifact.relativePath;
-    const agentFilePath = `{project-root}/${this.xiaomaFolderName}/${agentPath}`;
-
-    // xmc/config.yaml is safe to hardcode: agent activators are only generated from
-    // xmc agent artifacts, so xmc is guaranteed to be installed.
-    return `---
-description: '${safeDescription}'
-agent: 'agent'
-tools: ${toolsStr}
----
-
-1. Load {project-root}/${this.xiaomaFolderName}/xmc/config.yaml and store ALL fields as session variables
-2. Load the full agent file from ${agentFilePath}
-3. Follow ALL activation instructions in the agent file
-4. Display the welcome/greeting as instructed
-5. Present the numbered menu
-6. Wait for user input before proceeding
-`;
-  }
-
-  /**
-   * Generate copilot-instructions.md from module config
-   * @param {string} projectDir - Project directory
-   * @param {string} xiaomaDir - XIAOMA installation directory
-   * @param {Map} agentManifest - Agent manifest data
-   */
-  async generateCopilotInstructions(projectDir, xiaomaDir, agentManifest, options = {}) {
-    const configVars = await this.loadModuleConfig(xiaomaDir);
-
-    // Build the agents table from the manifest
-    let agentsTable = '| Agent | Persona | Title | Capabilities |\n|---|---|---|---|\n';
-    const agentOrder = [
-      'xiaoma-master',
-      'analyst',
-      'architect',
-      'dev',
-      'pm',
-      'qa',
-      'quick-flow-solo-dev',
-      'sm',
-      'tech-writer',
-      'ux-designer',
-    ];
-
-    for (const agentName of agentOrder) {
-      const meta = agentManifest.get(agentName);
-      if (meta) {
-        const capabilities = meta.capabilities || 'agent capabilities';
-        const cleanTitle = (meta.title || '').replaceAll('""', '"');
-        agentsTable += `| ${agentName} | ${meta.displayName} | ${cleanTitle} | ${capabilities} |\n`;
-      }
-    }
-
-    const xiaoma = this.xiaomaFolderName;
-    const xiaomaSection = `# XIAOMA Method — Project Instructions
-
-## Project Configuration
-
-- **Project**: ${configVars.project_name || '{{project_name}}'}
-- **User**: ${configVars.user_name || '{{user_name}}'}
-- **Communication Language**: ${configVars.communication_language || '{{communication_language}}'}
-- **Document Output Language**: ${configVars.document_output_language || '{{document_output_language}}'}
-- **User Skill Level**: ${configVars.user_skill_level || '{{user_skill_level}}'}
-- **Output Folder**: ${configVars.output_folder || '{{output_folder}}'}
-- **Planning Artifacts**: ${configVars.planning_artifacts || '{{planning_artifacts}}'}
-- **Implementation Artifacts**: ${configVars.implementation_artifacts || '{{implementation_artifacts}}'}
-- **Project Knowledge**: ${configVars.project_knowledge || '{{project_knowledge}}'}
-
-## XIAOMA Runtime Structure
-
-- **Agent definitions**: \`${xiaoma}/xmc/agents/\` (XMC module) and \`${xiaoma}/core/agents/\` (core)
-- **Workflow definitions**: \`${xiaoma}/xmc/workflows/\` (organized by phase)
-- **Core tasks**: \`${xiaoma}/core/tasks/\` (help, editorial review, indexing, sharding, adversarial review)
-- **Core workflows**: \`${xiaoma}/core/workflows/\` (brainstorming, party-mode, advanced-elicitation)
-- **Workflow engine**: \`${xiaoma}/core/tasks/workflow.xml\` (executes YAML-based workflows)
-- **Module configuration**: \`${xiaoma}/xmc/config.yaml\`
-- **Core configuration**: \`${xiaoma}/core/config.yaml\`
-- **Agent manifest**: \`${xiaoma}/_config/agent-manifest.csv\`
-- **Workflow manifest**: \`${xiaoma}/_config/workflow-manifest.csv\`
-- **Help manifest**: \`${xiaoma}/_config/xiaoma-help.csv\`
-- **Agent memory**: \`${xiaoma}/_memory/\`
-
-## Key Conventions
-
-- Always load \`${xiaoma}/xmc/config.yaml\` before any agent activation or workflow execution
-- Store all config fields as session variables: \`{user_name}\`, \`{communication_language}\`, \`{output_folder}\`, \`{planning_artifacts}\`, \`{implementation_artifacts}\`, \`{project_knowledge}\`
-- MD-based workflows execute directly — load and follow the \`.md\` file
-- YAML-based workflows require the workflow engine — load \`workflow.xml\` first, then pass the \`.yaml\` config
-- Follow step-based workflow execution: load steps JIT, never multiple at once
-- Save outputs after EACH step when using the workflow engine
-- The \`{project-root}\` variable resolves to the workspace root at runtime
-
-## Available Agents
-
-${agentsTable}
-## Slash Commands
-
-Type \`/xiaoma-\` in Copilot Chat to see all available XIAOMA workflows and agent activators. Agents are also available in the agents dropdown.`;
-
-    const instructionsPath = path.join(projectDir, this.githubDir, 'copilot-instructions.md');
-    const markerStart = '<!-- XIAOMA:START -->';
-    const markerEnd = '<!-- XIAOMA:END -->';
-    const markedContent = `${markerStart}\n${xiaomaSection}\n${markerEnd}`;
-
-    if (await fs.pathExists(instructionsPath)) {
-      const existing = await fs.readFile(instructionsPath, 'utf8');
-      const startIdx = existing.indexOf(markerStart);
-      const endIdx = existing.indexOf(markerEnd);
-
-      if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
-        // Replace only the XIAOMA section between markers
-        const before = existing.slice(0, startIdx);
-        const after = existing.slice(endIdx + markerEnd.length);
-        const merged = `${before}${markedContent}${after}`;
-        await this.writeFile(instructionsPath, merged);
-      } else {
-        // Existing file without markers — back it up before overwriting
-        const backupPath = `${instructionsPath}.bak`;
-        await fs.copy(instructionsPath, backupPath);
-        if (!options.silent) await prompts.log.warn(`  Backed up copilot-instructions.md → .bak`);
-        await this.writeFile(instructionsPath, `${markedContent}\n`);
-      }
-    } else {
-      // No existing file — create fresh with markers
-      await this.writeFile(instructionsPath, `${markedContent}\n`);
-    }
-  }
-
-  /**
-   * Load module config.yaml for template variables
-   * @param {string} xiaomaDir - XIAOMA installation directory
-   * @returns {Object} Config variables
-   */
-  async loadModuleConfig(xiaomaDir) {
-    const xmcConfigPath = path.join(xiaomaDir, 'xmc', 'config.yaml');
-    const coreConfigPath = path.join(xiaomaDir, 'core', 'config.yaml');
-
-    for (const configPath of [xmcConfigPath, coreConfigPath]) {
-      if (await fs.pathExists(configPath)) {
-        try {
-          const content = await fs.readFile(configPath, 'utf8');
-          return yaml.parse(content) || {};
-        } catch {
-          // Fall through to next config
-        }
-      }
-    }
-
-    return {};
-  }
-
-  /**
-   * Escape a string for use inside YAML single-quoted values.
-   * In YAML, the only escape inside single quotes is '' for a literal '.
-   * @param {string} value - Raw string
-   * @returns {string} Escaped string safe for YAML single-quoted context
-   */
-  escapeYamlSingleQuote(value) {
-    return (value || '').replaceAll("'", "''");
-  }
-
-  /**
-   * Scan existing agent and prompt files for customised tool permissions before cleanup.
-   * Returns a Map<filename, toolsArray> so permissions can be preserved across reinstalls.
-   * @param {string} projectDir - Project directory
-   * @returns {Map} Existing tool permissions keyed by filename
-   */
-  async collectExistingToolPermissions(projectDir) {
-    const permissions = new Map();
-    const dirs = [
-      [path.join(projectDir, this.githubDir, this.agentsDir), /^xiaoma.*\.agent\.md$/],
-      [path.join(projectDir, this.githubDir, this.promptsDir), /^xiaoma-.*\.prompt\.md$/],
-    ];
-
-    for (const [dir, pattern] of dirs) {
-      if (!(await fs.pathExists(dir))) continue;
-      const files = await fs.readdir(dir);
-
-      for (const file of files) {
-        if (!pattern.test(file)) continue;
-
-        try {
-          const content = await fs.readFile(path.join(dir, file), 'utf8');
-          const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-          if (!fmMatch) continue;
-
-          const frontmatter = yaml.parse(fmMatch[1]);
-          if (frontmatter && Array.isArray(frontmatter.tools)) {
-            permissions.set(file, frontmatter.tools);
-          }
-        } catch {
-          // Skip unreadable files
-        }
-      }
-    }
-
-    return permissions;
-  }
-
-  /**
-   * Get the tools array string for a file, preserving any existing customisation.
-   * Falls back to the default tools if no prior customisation exists.
-   * @param {string} fileName - Target filename (e.g. 'xiaoma-agent-xmc-pm.agent.md')
-   * @returns {string} YAML inline array string
-   */
-  getToolsForFile(fileName) {
-    const defaultTools = ['read', 'edit', 'search', 'execute'];
-    const tools = (this.existingToolPermissions && this.existingToolPermissions.get(fileName)) || defaultTools;
-    return '[' + tools.map((t) => `'${t}'`).join(', ') + ']';
-  }
-
-  /**
-   * Format name as title
-   */
-  formatTitle(name) {
-    return name
-      .split('-')
-      .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  /**
-   * Cleanup GitHub Copilot configuration - surgically remove only XIAOMA files
-   */
-  async cleanup(projectDir, options = {}) {
-    // Clean up agents directory
-    const agentsDir = path.join(projectDir, this.githubDir, this.agentsDir);
-    if (await fs.pathExists(agentsDir)) {
-      const files = await fs.readdir(agentsDir);
-      let removed = 0;
-
-      for (const file of files) {
-        if (file.startsWith('xiaoma') && (file.endsWith('.agent.md') || file.endsWith('.md'))) {
-          await fs.remove(path.join(agentsDir, file));
-          removed++;
-        }
-      }
-
-      if (removed > 0 && !options.silent) {
-        await prompts.log.message(`  Cleaned up ${removed} existing XIAOMA agents`);
-      }
-    }
-
-    // Clean up prompts directory
-    const promptsDir = path.join(projectDir, this.githubDir, this.promptsDir);
-    if (await fs.pathExists(promptsDir)) {
-      const files = await fs.readdir(promptsDir);
-      let removed = 0;
-
-      for (const file of files) {
-        if (file.startsWith('xiaoma-') && file.endsWith('.prompt.md')) {
-          await fs.remove(path.join(promptsDir, file));
-          removed++;
-        }
-      }
-
-      if (removed > 0 && !options.silent) {
-        await prompts.log.message(`  Cleaned up ${removed} existing XIAOMA prompts`);
-      }
-    }
-
-    // During uninstall, also strip XIAOMA markers from copilot-instructions.md.
-    // During reinstall (default), this is skipped because generateCopilotInstructions()
-    // handles marker-based replacement in a single read-modify-write pass,
-    // which correctly preserves user content outside the markers.
-    if (options.isUninstall) {
-      await this.cleanupCopilotInstructions(projectDir, options);
-    }
-  }
-
-  /**
-   * Strip XIAOMA marker section from copilot-instructions.md
-   * If file becomes empty after stripping, delete it.
-   * If a .bak backup exists and the main file was deleted, restore the backup.
-   * @param {string} projectDir - Project directory
-   * @param {Object} [options] - Options (e.g. { silent: true })
-   */
-  async cleanupCopilotInstructions(projectDir, options = {}) {
-    const instructionsPath = path.join(projectDir, this.githubDir, 'copilot-instructions.md');
-    const backupPath = `${instructionsPath}.bak`;
-
-    if (!(await fs.pathExists(instructionsPath))) {
-      return;
-    }
-
-    const content = await fs.readFile(instructionsPath, 'utf8');
-    const markerStart = '<!-- XIAOMA:START -->';
-    const markerEnd = '<!-- XIAOMA:END -->';
-    const startIdx = content.indexOf(markerStart);
-    const endIdx = content.indexOf(markerEnd);
-
-    if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx) {
-      return; // No valid markers found
-    }
-
-    // Strip the marker section (including markers)
-    const before = content.slice(0, startIdx);
-    const after = content.slice(endIdx + markerEnd.length);
-    const cleaned = before + after;
-
-    if (cleaned.trim().length === 0) {
-      // File is empty after stripping — delete it
-      await fs.remove(instructionsPath);
-
-      // If backup exists, restore it
-      if (await fs.pathExists(backupPath)) {
-        await fs.rename(backupPath, instructionsPath);
-        if (!options.silent) {
-          await prompts.log.message('  Restored copilot-instructions.md from backup');
-        }
-      }
-    } else {
-      // Write cleaned content back (preserve original whitespace)
-      await fs.writeFile(instructionsPath, cleaned, 'utf8');
-
-      // If backup exists, it's stale now — remove it
-      if (await fs.pathExists(backupPath)) {
-        await fs.remove(backupPath);
-      }
-    }
-  }
-}
-
-module.exports = { GitHubCopilotSetup };