@zeyue0329/xiaoma-cli 1.12.0 → 1.15.0

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

@@ -1,136 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const yaml = require('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.parse(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) {
-    // Use forward slashes for glob pattern (works on both Windows and Unix)
-    // Convert backslashes to forward slashes for glob compatibility
-    const normalizedSourceDir = sourceDir.replaceAll('\\', '/');
-    const pattern = `${normalizedSourceDir}/**/${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

@@ -1,368 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const csv = require('csv-parse/sync');
-const { toColonName, toColonPath, toDashPath, XiaoMa_FOLDER_NAME } = require('./path-utils');
-
-/**
- * Generates command files for standalone tasks and tools
- */
-class TaskToolCommandGenerator {
-  /**
-   * @param {string} xiaomaFolderName - Name of the XiaoMa folder for template rendering (default: '_xiaoma')
-   * Note: This parameter is accepted for API consistency with AgentCommandGenerator and
-   * WorkflowCommandGenerator, but is not used for path stripping. The manifest always stores
-   * filesystem paths with '_xiaoma/' prefix (the actual folder name), while xiaomaFolderName is
-   * used for template placeholder rendering ({{xiaomaFolderName}}).
-   */
-  constructor(xiaomaFolderName = XiaoMa_FOLDER_NAME) {
-    this.xiaomaFolderName = xiaomaFolderName;
-  }
-
-  /**
-   * Collect task and tool artifacts for IDE installation
-   * @param {string} xiaomaDir - XiaoMa installation directory
-   * @returns {Promise<Object>} Artifacts array with metadata
-   */
-  async collectTaskToolArtifacts(xiaomaDir) {
-    const tasks = await this.loadTaskManifest(xiaomaDir);
-    const tools = await this.loadToolManifest(xiaomaDir);
-
-    // All tasks/tools in manifest are standalone (internal=true items are filtered during manifest generation)
-    const artifacts = [];
-    const xiaomaPrefix = `${XiaoMa_FOLDER_NAME}/`;
-
-    // Collect task artifacts
-    for (const task of tasks || []) {
-      let taskPath = (task.path || '').replaceAll('\\', '/');
-      // Convert absolute paths to relative paths
-      if (path.isAbsolute(taskPath)) {
-        taskPath = path.relative(xiaomaDir, taskPath).replaceAll('\\', '/');
-      }
-      // Remove _xiaoma/ prefix if present to get relative path within xiaoma folder
-      if (taskPath.startsWith(xiaomaPrefix)) {
-        taskPath = taskPath.slice(xiaomaPrefix.length);
-      }
-
-      const taskExt = path.extname(taskPath) || '.md';
-      artifacts.push({
-        type: 'task',
-        name: task.name,
-        displayName: task.displayName || task.name,
-        description: task.description || `Execute ${task.displayName || task.name}`,
-        module: task.module,
-        canonicalId: task.canonicalId || '',
-        // Use forward slashes for cross-platform consistency (not path.join which uses backslashes on Windows)
-        relativePath: `${task.module}/tasks/${task.name}${taskExt}`,
-        path: taskPath,
-      });
-    }
-
-    // Collect tool artifacts
-    for (const tool of tools || []) {
-      let toolPath = (tool.path || '').replaceAll('\\', '/');
-      // Convert absolute paths to relative paths
-      if (path.isAbsolute(toolPath)) {
-        toolPath = path.relative(xiaomaDir, toolPath).replaceAll('\\', '/');
-      }
-      // Remove _xiaoma/ prefix if present to get relative path within xiaoma folder
-      if (toolPath.startsWith(xiaomaPrefix)) {
-        toolPath = toolPath.slice(xiaomaPrefix.length);
-      }
-
-      const toolExt = path.extname(toolPath) || '.md';
-      artifacts.push({
-        type: 'tool',
-        name: tool.name,
-        displayName: tool.displayName || tool.name,
-        description: tool.description || `Execute ${tool.displayName || tool.name}`,
-        module: tool.module,
-        canonicalId: tool.canonicalId || '',
-        // Use forward slashes for cross-platform consistency (not path.join which uses backslashes on Windows)
-        relativePath: `${tool.module}/tools/${tool.name}${toolExt}`,
-        path: toolPath,
-      });
-    }
-
-    return {
-      artifacts,
-      counts: {
-        tasks: (tasks || []).length,
-        tools: (tools || []).length,
-      },
-    };
-  }
-
-  /**
-   * 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);
-
-    // 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 tasks || []) {
-      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 tools || []) {
-      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: (tasks || []).length,
-      tools: (tools || []).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
-    // Handle undefined/missing path by constructing from module and name
-    let itemPath = item.path;
-    if (!itemPath || typeof itemPath !== 'string') {
-      // Fallback: construct path from module and name if path is missing
-      const typePlural = type === 'task' ? 'tasks' : 'tools';
-      itemPath = `{project-root}/${this.xiaomaFolderName}/${item.module}/${typePlural}/${item.name}.md`;
-    } else {
-      // Normalize path separators to forward slashes
-      itemPath = itemPath.replaceAll('\\', '/');
-
-      // Extract relative path from absolute paths (Windows or Unix)
-      // Look for _xiaoma/ or xiaoma/ in the path and extract everything after it
-      // Match patterns like: /_xiaoma/core/tasks/... or /xiaoma/core/tasks/...
-      // Use [/\\] to handle both Unix forward slashes and Windows backslashes,
-      // and also paths without a leading separator (e.g., C:/_xiaoma/...)
-      const xiaomaMatch = itemPath.match(/[/\\]_xiaoma[/\\](.+)$/) || itemPath.match(/[/\\]xiaoma[/\\](.+)$/);
-      if (xiaomaMatch) {
-        // Found /_xiaoma/ or /xiaoma/ - use relative path after it
-        itemPath = `{project-root}/${this.xiaomaFolderName}/${xiaomaMatch[1]}`;
-      } else if (itemPath.startsWith(`${XiaoMa_FOLDER_NAME}/`)) {
-        // Relative path starting with _xiaoma/
-        itemPath = `{project-root}/${this.xiaomaFolderName}/${itemPath.slice(XiaoMa_FOLDER_NAME.length + 1)}`;
-      } else if (itemPath.startsWith('xiaoma/')) {
-        // Relative path starting with xiaoma/
-        itemPath = `{project-root}/${this.xiaomaFolderName}/${itemPath.slice(5)}`;
-      } else if (!itemPath.startsWith('{project-root}')) {
-        // For other relative paths, prefix with project root and xiaoma folder
-        itemPath = `{project-root}/${this.xiaomaFolderName}/${itemPath}`;
-      }
-    }
-
-    return `---
-description: '${description.replaceAll("'", "''")}'
----
-
-# ${item.displayName || item.name}
-
-Read the entire ${type} file at: ${itemPath}
-
-Follow all instructions in the ${type} file exactly as written.
-`;
-  }
-
-  /**
-   * Load task manifest CSV
-   */
-  async loadTaskManifest(xiaomaDir) {
-    const manifestPath = path.join(xiaomaDir, '_config', '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, '_config', '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,
-    });
-  }
-
-  /**
-   * Generate task and tool commands using underscore format (Windows-compatible)
-   * Creates flat files like: xiaoma_bmm_help.md
-   *
-   * @param {string} projectDir - Project directory
-   * @param {string} xiaomaDir - XiaoMa installation directory
-   * @param {string} baseCommandsDir - Base commands directory for the IDE
-   * @returns {Object} Generation results
-   */
-  async generateColonTaskToolCommands(projectDir, xiaomaDir, baseCommandsDir) {
-    const tasks = await this.loadTaskManifest(xiaomaDir);
-    const tools = await this.loadToolManifest(xiaomaDir);
-
-    let generatedCount = 0;
-
-    // Generate command files for tasks
-    for (const task of tasks || []) {
-      const commandContent = this.generateCommandContent(task, 'task');
-      // Use underscore format: xiaoma_bmm_name.md
-      const flatName = toColonName(task.module, 'tasks', task.name);
-      const commandPath = path.join(baseCommandsDir, flatName);
-      await fs.ensureDir(path.dirname(commandPath));
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    // Generate command files for tools
-    for (const tool of tools || []) {
-      const commandContent = this.generateCommandContent(tool, 'tool');
-      // Use underscore format: xiaoma_bmm_name.md
-      const flatName = toColonName(tool.module, 'tools', tool.name);
-      const commandPath = path.join(baseCommandsDir, flatName);
-      await fs.ensureDir(path.dirname(commandPath));
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    return {
-      generated: generatedCount,
-      tasks: (tasks || []).length,
-      tools: (tools || []).length,
-    };
-  }
-
-  /**
-   * Generate task and tool commands using underscore format (Windows-compatible)
-   * Creates flat files like: xiaoma_bmm_help.md
-   *
-   * @param {string} projectDir - Project directory
-   * @param {string} xiaomaDir - XiaoMa installation directory
-   * @param {string} baseCommandsDir - Base commands directory for the IDE
-   * @returns {Object} Generation results
-   */
-  async generateDashTaskToolCommands(projectDir, xiaomaDir, baseCommandsDir) {
-    const tasks = await this.loadTaskManifest(xiaomaDir);
-    const tools = await this.loadToolManifest(xiaomaDir);
-
-    let generatedCount = 0;
-
-    // Generate command files for tasks
-    for (const task of tasks || []) {
-      const commandContent = this.generateCommandContent(task, 'task');
-      // Use dash format: xiaoma-xmc-name.md
-      const flatName = toDashPath(`${task.module}/tasks/${task.name}.md`);
-      const commandPath = path.join(baseCommandsDir, flatName);
-      await fs.ensureDir(path.dirname(commandPath));
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    // Generate command files for tools
-    for (const tool of tools || []) {
-      const commandContent = this.generateCommandContent(tool, 'tool');
-      // Use dash format: xiaoma-xmc-name.md
-      const flatName = toDashPath(`${tool.module}/tools/${tool.name}.md`);
-      const commandPath = path.join(baseCommandsDir, flatName);
-      await fs.ensureDir(path.dirname(commandPath));
-      await fs.writeFile(commandPath, commandContent);
-      generatedCount++;
-    }
-
-    return {
-      generated: generatedCount,
-      tasks: (tasks || []).length,
-      tools: (tools || []).length,
-    };
-  }
-
-  /**
-   * Write task/tool artifacts using underscore format (Windows-compatible)
-   * Creates flat files like: xiaoma_bmm_help.md
-   *
-   * @param {string} baseCommandsDir - Base commands directory for the IDE
-   * @param {Array} artifacts - Task/tool artifacts with relativePath
-   * @returns {number} Count of commands written
-   */
-  async writeColonArtifacts(baseCommandsDir, artifacts) {
-    let writtenCount = 0;
-
-    for (const artifact of artifacts) {
-      if (artifact.type === 'task' || artifact.type === 'tool') {
-        const commandContent = this.generateCommandContent(artifact, artifact.type);
-        // Use underscore format: xiaoma_module_name.md
-        const flatName = toColonPath(artifact.relativePath);
-        const commandPath = path.join(baseCommandsDir, flatName);
-        await fs.ensureDir(path.dirname(commandPath));
-        await fs.writeFile(commandPath, commandContent);
-        writtenCount++;
-      }
-    }
-
-    return writtenCount;
-  }
-
-  /**
-   * Write task/tool artifacts using dash format (NEW STANDARD)
-   * Creates flat files like: xiaoma-xmc-help.md
-   *
-   * Note: Tasks/tools do NOT have xiaoma-agent- prefix - only agents do.
-   *
-   * @param {string} baseCommandsDir - Base commands directory for the IDE
-   * @param {Array} artifacts - Task/tool artifacts with relativePath
-   * @returns {number} Count of commands written
-   */
-  async writeDashArtifacts(baseCommandsDir, artifacts) {
-    let writtenCount = 0;
-
-    for (const artifact of artifacts) {
-      if (artifact.type === 'task' || artifact.type === 'tool') {
-        const commandContent = this.generateCommandContent(artifact, artifact.type);
-        // Use dash format: xiaoma-module-name.md
-        const flatName = toDashPath(artifact.relativePath);
-        const commandPath = path.join(baseCommandsDir, flatName);
-        await fs.ensureDir(path.dirname(commandPath));
-        await fs.writeFile(commandPath, commandContent);
-        writtenCount++;
-      }
-    }
-
-    return writtenCount;
-  }
-}
-
-module.exports = { TaskToolCommandGenerator };

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

@@ -1,179 +0,0 @@
-const path = require('node:path');
-const fs = require('fs-extra');
-const csv = require('csv-parse/sync');
-const { XiaoMa_FOLDER_NAME } = require('./path-utils');
-
-/**
- * Generates command files for each workflow in the manifest
- */
-class WorkflowCommandGenerator {
-  constructor(xiaomaFolderName = XiaoMa_FOLDER_NAME) {
-    this.xiaomaFolderName = xiaomaFolderName;
-  }
-
-  async collectWorkflowArtifacts(xiaomaDir) {
-    const workflows = await this.loadWorkflowManifest(xiaomaDir);
-
-    if (!workflows) {
-      return { artifacts: [], counts: { commands: 0, launchers: 0 } };
-    }
-
-    // ALL workflows now generate commands - no standalone filtering
-    const allWorkflows = workflows;
-
-    const artifacts = [];
-
-    for (const workflow of allWorkflows) {
-      // Calculate the relative workflow path (e.g., xmc/workflows/4-implementation/sprint-planning/workflow.md)
-      let workflowRelPath = workflow.path || '';
-      // Normalize path separators for cross-platform compatibility
-      workflowRelPath = workflowRelPath.replaceAll('\\', '/');
-      // Remove _xiaoma/ prefix if present to get relative path from project root
-      // Handle both absolute paths (/path/to/_xiaoma/...) and relative paths (_xiaoma/...)
-      if (workflowRelPath.includes('_xiaoma/')) {
-        const parts = workflowRelPath.split(/_xiaoma\//);
-        if (parts.length > 1) {
-          workflowRelPath = parts.slice(1).join('/');
-        }
-      } else if (workflowRelPath.includes('/src/')) {
-        // Normalize source paths (e.g. .../src/xmc/...) to relative module path (e.g. xmc/...)
-        const match = workflowRelPath.match(/\/src\/([^/]+)\/(.+)/);
-        if (match) {
-          workflowRelPath = `${match[1]}/${match[2]}`;
-        }
-      }
-      artifacts.push({
-        type: 'workflow-command',
-        name: workflow.name,
-        description: workflow.description || `${workflow.name} workflow`,
-        module: workflow.module,
-        canonicalId: workflow.canonicalId || '',
-        relativePath: path.join(workflow.module, 'workflows', `${workflow.name}.md`),
-        workflowPath: workflowRelPath, // Relative path to actual workflow file
-        sourcePath: workflow.path,
-      });
-    }
-
-    const groupedWorkflows = this.groupWorkflowsByModule(allWorkflows);
-    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: allWorkflows.length,
-        launchers: Object.keys(groupedWorkflows).length,
-      },
-    };
-  }
-
-  /**
-   * 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 the workflow.md file at the path shown above
-2. READ its entire contents and follow its directions exactly
-3. Save outputs after EACH section
-
-## Modes
-- Normal: Full interaction
-- #yolo: Skip optional steps
-`;
-
-    return content;
-  }
-
-  transformWorkflowPath(workflowPath) {
-    let transformed = workflowPath;
-
-    if (workflowPath.includes('/src/xmc/')) {
-      const match = workflowPath.match(/\/src\/xmc\/(.+)/);
-      if (match) {
-        transformed = `{project-root}/${this.xiaomaFolderName}/xmc/${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, '_config', '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 };