scm-method 1.0.0

package/tools/installer/ide/shared/module-injections.js

@@ -0,0 +1,136 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('yaml');
+const { glob } = require('glob');
+const { getSourcePath } = require('../../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/installer/ide/shared/path-utils.js

@@ -0,0 +1,364 @@
+/**
+ * Path transformation utilities for IDE installer standardization
+ *
+ * Provides utilities to convert hierarchical paths to flat naming conventions.
+ *
+ * DASH-BASED NAMING (new standard):
+ * - Agents: scm-agent-module-name.md (with scm-agent- prefix)
+ * - Workflows/Tasks/Tools: scm-module-name.md
+ *
+ * Example outputs:
+ * - cis/agents/storymaster.md → scm-agent-cis-storymaster.md
+ * - bmm/workflows/plan-project.md → scm-bmm-plan-project.md
+ * - bmm/tasks/create-story.md → scm-bmm-create-story.md
+ * - core/agents/brainstorming.md → scm-agent-brainstorming.md (core agents skip module name)
+ * - standalone/agents/fred.md → scm-agent-standalone-fred.md
+ */
+
+// Type segments - agents are included in naming, others are filtered out
+const TYPE_SEGMENTS = ['workflows', 'tasks', 'tools'];
+const AGENT_SEGMENT = 'agents';
+
+// SCM installation folder name - centralized constant for all installers
+const SCM_FOLDER_NAME = '_scm';
+
+/**
+ * Convert hierarchical path to flat dash-separated name (NEW STANDARD)
+ * Converts: 'bmm', 'agents', 'pm' → 'scm-agent-bmm-pm.md'
+ * Converts: 'bmm', 'workflows', 'correct-course' → 'scm-bmm-correct-course.md'
+ * Converts: 'core', 'agents', 'brainstorming' → 'scm-agent-brainstorming.md' (core agents skip module name)
+ * Converts: 'standalone', 'agents', 'fred' → 'scm-agent-standalone-fred.md'
+ *
+ * @param {string} module - Module name (e.g., 'bmm', 'core', 'standalone')
+ * @param {string} type - Artifact type ('agents', 'workflows', 'tasks', 'tools')
+ * @param {string} name - Artifact name (e.g., 'pm', 'brainstorming')
+ * @returns {string} Flat filename like 'scm-agent-bmm-pm.md' or 'scm-bmm-correct-course.md'
+ */
+function toDashName(module, type, name) {
+  const isAgent = type === AGENT_SEGMENT;
+
+  // For core module, skip the module name: use 'scm-agent-name.md' instead of 'scm-agent-core-name.md'
+  if (module === 'core') {
+    return isAgent ? `scm-agent-${name}.md` : `scm-${name}.md`;
+  }
+  // For standalone module, include 'standalone' in the name
+  if (module === 'standalone') {
+    return isAgent ? `scm-agent-standalone-${name}.md` : `scm-standalone-${name}.md`;
+  }
+
+  // Module artifacts: scm-module-name.md or scm-agent-module-name.md
+  // eslint-disable-next-line unicorn/prefer-string-replace-all -- regex replace is intentional here
+  const dashName = name.replace(/\//g, '-'); // Flatten nested paths
+  return isAgent ? `scm-agent-${module}-${dashName}.md` : `scm-${module}-${dashName}.md`;
+}
+
+/**
+ * Convert relative path to flat dash-separated name
+ * Converts: 'bmm/agents/pm.md' → 'scm-agent-bmm-pm.md'
+ * Converts: 'bmm/agents/tech-writer/tech-writer.md' → 'scm-agent-bmm-tech-writer.md' (uses folder name)
+ * Converts: 'bmm/workflows/correct-course.md' → 'scm-bmm-correct-course.md'
+ * Converts: 'core/agents/brainstorming.md' → 'scm-agent-brainstorming.md' (core agents skip module name)
+ *
+ * @param {string} relativePath - Path like 'bmm/agents/pm.md'
+ * @returns {string} Flat filename like 'scm-agent-bmm-pm.md' or 'scm-brainstorming.md'
+ */
+function toDashPath(relativePath) {
+  if (!relativePath || typeof relativePath !== 'string') {
+    // Return a safe default for invalid input
+    return 'scm-unknown.md';
+  }
+
+  // Strip common file extensions to avoid double extensions in generated filenames
+  // e.g., 'create-story.xml' → 'create-story', 'workflow.md' → 'workflow'
+  const withoutExt = relativePath.replace(/\.(md|yaml|yml|json|xml|toml)$/i, '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1];
+  let name;
+
+  // For agents, if nested in a folder (more than 3 parts), use the folder name only
+  // e.g., 'bmm/agents/tech-writer/tech-writer' → 'tech-writer' (not 'tech-writer-tech-writer')
+  if (type === 'agents' && parts.length > 3) {
+    // Use the folder name (parts[2]) as the name, ignore the file name
+    name = parts[2];
+  } else {
+    // For non-nested or non-agents, join all parts after type
+    name = parts.slice(2).join('-');
+  }
+
+  return toDashName(module, type, name);
+}
+
+/**
+ * Create custom agent dash name
+ * Creates: 'scm-custom-agent-fred-commit-poet.md'
+ *
+ * @param {string} agentName - Custom agent name
+ * @returns {string} Flat filename like 'scm-custom-agent-fred-commit-poet.md'
+ */
+function customAgentDashName(agentName) {
+  return `scm-custom-agent-${agentName}.md`;
+}
+
+/**
+ * Check if a filename uses dash format
+ * @param {string} filename - Filename to check
+ * @returns {boolean} True if filename uses dash format
+ */
+function isDashFormat(filename) {
+  return filename.startsWith('scm-') && filename.includes('-');
+}
+
+/**
+ * Extract parts from a dash-formatted filename
+ * Parses: 'scm-agent-bmm-pm.md' → { prefix: 'scm', module: 'bmm', type: 'agents', name: 'pm' }
+ * Parses: 'scm-bmm-correct-course.md' → { prefix: 'scm', module: 'bmm', type: 'workflows', name: 'correct-course' }
+ * Parses: 'scm-agent-brainstorming.md' → { prefix: 'scm', module: 'core', type: 'agents', name: 'brainstorming' } (core agents)
+ * Parses: 'scm-brainstorming.md' → { prefix: 'scm', module: 'core', type: 'workflows', name: 'brainstorming' } (core workflows)
+ * Parses: 'scm-agent-standalone-fred.md' → { prefix: 'scm', module: 'standalone', type: 'agents', name: 'fred' }
+ * Parses: 'scm-standalone-foo.md' → { prefix: 'scm', module: 'standalone', type: 'workflows', name: 'foo' }
+ *
+ * @param {string} filename - Dash-formatted filename
+ * @returns {Object|null} Parsed parts or null if invalid format
+ */
+function parseDashName(filename) {
+  const withoutExt = filename.replace('.md', '');
+  const parts = withoutExt.split('-');
+
+  if (parts.length < 2 || parts[0] !== 'scm') {
+    return null;
+  }
+
+  // Check if this is an agent file (has 'agent' as second part)
+  const isAgent = parts[1] === 'agent';
+
+  if (isAgent) {
+    // This is an agent file
+    // Format: scm-agent-name (core) or scm-agent-standalone-name or scm-agent-module-name
+    if (parts.length >= 4 && parts[2] === 'standalone') {
+      // Standalone agent: scm-agent-standalone-name
+      return {
+        prefix: parts[0],
+        module: 'standalone',
+        type: 'agents',
+        name: parts.slice(3).join('-'),
+      };
+    }
+    if (parts.length === 3) {
+      // Core agent: scm-agent-name
+      return {
+        prefix: parts[0],
+        module: 'core',
+        type: 'agents',
+        name: parts[2],
+      };
+    } else {
+      // Module agent: scm-agent-module-name
+      return {
+        prefix: parts[0],
+        module: parts[2],
+        type: 'agents',
+        name: parts.slice(3).join('-'),
+      };
+    }
+  }
+
+  // Not an agent file - must be a workflow/tool/task
+  // If only 2 parts (scm-name), it's a core workflow/tool/task
+  if (parts.length === 2) {
+    return {
+      prefix: parts[0],
+      module: 'core',
+      type: 'workflows', // Default to workflows for non-agent core items
+      name: parts[1],
+    };
+  }
+
+  // Check for standalone non-agent: scm-standalone-name
+  if (parts[1] === 'standalone') {
+    return {
+      prefix: parts[0],
+      module: 'standalone',
+      type: 'workflows', // Default to workflows for non-agent standalone items
+      name: parts.slice(2).join('-'),
+    };
+  }
+
+  // Otherwise, it's a module workflow/tool/task (scm-module-name)
+  return {
+    prefix: parts[0],
+    module: parts[1],
+    type: 'workflows', // Default to workflows for non-agent module items
+    name: parts.slice(2).join('-'),
+  };
+}
+
+// ============================================================================
+// LEGACY FUNCTIONS (underscore format) - kept for backward compatibility
+// ============================================================================
+
+/**
+ * Convert hierarchical path to flat underscore-separated name (LEGACY)
+ * @deprecated Use toDashName instead
+ */
+function toUnderscoreName(module, type, name) {
+  const isAgent = type === AGENT_SEGMENT;
+  if (module === 'core') {
+    return isAgent ? `scm_agent_${name}.md` : `scm_${name}.md`;
+  }
+  if (module === 'standalone') {
+    return isAgent ? `scm_agent_standalone_${name}.md` : `scm_standalone_${name}.md`;
+  }
+  return isAgent ? `scm_${module}_agent_${name}.md` : `scm_${module}_${name}.md`;
+}
+
+/**
+ * Convert relative path to flat underscore-separated name (LEGACY)
+ * @deprecated Use toDashPath instead
+ */
+function toUnderscorePath(relativePath) {
+  // Strip common file extensions (same as toDashPath for consistency)
+  const withoutExt = relativePath.replace(/\.(md|yaml|yml|json|xml|toml)$/i, '');
+  const parts = withoutExt.split(/[/\\]/);
+
+  const module = parts[0];
+  const type = parts[1];
+  const name = parts.slice(2).join('_');
+
+  return toUnderscoreName(module, type, name);
+}
+
+/**
+ * Create custom agent underscore name (LEGACY)
+ * @deprecated Use customAgentDashName instead
+ */
+function customAgentUnderscoreName(agentName) {
+  return `scm_custom_${agentName}.md`;
+}
+
+/**
+ * Check if a filename uses underscore format (LEGACY)
+ * @deprecated Use isDashFormat instead
+ */
+function isUnderscoreFormat(filename) {
+  return filename.startsWith('scm_') && filename.includes('_');
+}
+
+/**
+ * Extract parts from an underscore-formatted filename (LEGACY)
+ * @deprecated Use parseDashName instead
+ */
+function parseUnderscoreName(filename) {
+  const withoutExt = filename.replace('.md', '');
+  const parts = withoutExt.split('_');
+
+  if (parts.length < 2 || parts[0] !== 'scm') {
+    return null;
+  }
+
+  const agentIndex = parts.indexOf('agent');
+
+  if (agentIndex !== -1) {
+    if (agentIndex === 1) {
+      // scm_agent_... - check for standalone
+      if (parts.length >= 4 && parts[2] === 'standalone') {
+        return {
+          prefix: parts[0],
+          module: 'standalone',
+          type: 'agents',
+          name: parts.slice(3).join('_'),
+        };
+      }
+      return {
+        prefix: parts[0],
+        module: 'core',
+        type: 'agents',
+        name: parts.slice(agentIndex + 1).join('_'),
+      };
+    } else {
+      return {
+        prefix: parts[0],
+        module: parts[1],
+        type: 'agents',
+        name: parts.slice(agentIndex + 1).join('_'),
+      };
+    }
+  }
+
+  if (parts.length === 2) {
+    return {
+      prefix: parts[0],
+      module: 'core',
+      type: 'workflows',
+      name: parts[1],
+    };
+  }
+
+  // Check for standalone non-agent: scm_standalone_name
+  if (parts[1] === 'standalone') {
+    return {
+      prefix: parts[0],
+      module: 'standalone',
+      type: 'workflows',
+      name: parts.slice(2).join('_'),
+    };
+  }
+
+  return {
+    prefix: parts[0],
+    module: parts[1],
+    type: 'workflows',
+    name: parts.slice(2).join('_'),
+  };
+}
+
+/**
+ * Resolve the skill name for an artifact.
+ * Prefers canonicalId from a scm-skill-manifest.yaml sidecar when available,
+ * falling back to the path-derived name from toDashPath().
+ *
+ * @param {Object} artifact - Artifact object (must have relativePath; may have canonicalId)
+ * @returns {string} Filename like 'scm-create-prd.md' or 'scm-agent-bmm-pm.md'
+ */
+function resolveSkillName(artifact) {
+  if (artifact.canonicalId) {
+    return `${artifact.canonicalId}.md`;
+  }
+  return toDashPath(artifact.relativePath);
+}
+
+// Backward compatibility aliases (colon format was same as underscore)
+const toColonName = toUnderscoreName;
+const toColonPath = toUnderscorePath;
+const customAgentColonName = customAgentUnderscoreName;
+const isColonFormat = isUnderscoreFormat;
+const parseColonName = parseUnderscoreName;
+
+module.exports = {
+  // New standard (dash-based)
+  toDashName,
+  toDashPath,
+  resolveSkillName,
+  customAgentDashName,
+  isDashFormat,
+  parseDashName,
+
+  // Legacy (underscore-based) - kept for backward compatibility
+  toUnderscoreName,
+  toUnderscorePath,
+  customAgentUnderscoreName,
+  isUnderscoreFormat,
+  parseUnderscoreName,
+
+  // Backward compatibility aliases
+  toColonName,
+  toColonPath,
+  customAgentColonName,
+  isColonFormat,
+  parseColonName,
+
+  TYPE_SEGMENTS,
+  AGENT_SEGMENT,
+  SCM_FOLDER_NAME,
+};

package/tools/installer/ide/shared/scm-artifacts.js

@@ -0,0 +1,208 @@
+const path = require('node:path');
+const fs = require('fs-extra');
+const { loadSkillManifest, getCanonicalId } = require('./skill-manifest');
+
+/**
+ * Helpers for gathering SCM agents/tasks from the installed tree.
+ * Shared by installers that need Claude-style exports.
+ *
+ * TODO: Dead code cleanup — compiled XML agents are retired.
+ *
+ * All agents now use the SKILL.md directory format with scm-skill-manifest.yaml
+ * (type: agent). The legacy pipeline below only discovers compiled .md files
+ * containing <agent> XML tags, which no longer exist. The following are dead:
+ *
+ *   - getAgentsFromBmad()      — scans {module}/agents/ for .md files with <agent> tags
+ *   - getAgentsFromDir()       — recursive helper for the above
+ *   - AgentCommandGenerator    — (agent-command-generator.js) generates launcher .md files
+ *                                 that tell the LLM to load a compiled agent .md file
+ *   - agent-command-template.md — (templates/) the launcher template with hardcoded
+ *                                 {module}/agents/{{path}} reference
+ *
+ * Agent metadata for agent-manifest.csv is now handled entirely by
+ * ManifestGenerator.getAgentsFromDirRecursive() in manifest-generator.js,
+ * which walks the full module tree and finds type:agent directories.
+ *
+ * IDE installation of agents is handled by the native skill pipeline —
+ * each agent's SKILL.md directory is installed directly to the IDE's
+ * skills path, so no launcher intermediary is needed.
+ *
+ * Cleanup: remove getAgentsFromBmad, getAgentsFromDir, their exports,
+ * AgentCommandGenerator, agent-command-template.md, and all call sites
+ * in IDE installers that invoke collectAgentArtifacts / writeAgentLaunchers /
+ * writeColonArtifacts / writeDashArtifacts.
+ * getTasksFromBmad and getTasksFromDir may still be live — verify before removing.
+ */
+async function getAgentsFromBmad(scmDir, selectedModules = []) {
+  const agents = [];
+
+  // Get core agents
+  if (await fs.pathExists(path.join(scmDir, 'core', 'agents'))) {
+    const coreAgents = await getAgentsFromDir(path.join(scmDir, 'core', 'agents'), 'core');
+    agents.push(...coreAgents);
+  }
+
+  // Get module agents
+  for (const moduleName of selectedModules) {
+    const agentsPath = path.join(scmDir, moduleName, 'agents');
+
+    if (await fs.pathExists(agentsPath)) {
+      const moduleAgents = await getAgentsFromDir(agentsPath, moduleName);
+      agents.push(...moduleAgents);
+    }
+  }
+
+  // Get standalone agents from scm/agents/ directory
+  const standaloneAgentsDir = path.join(scmDir, '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);
+      const skillManifest = await loadSkillManifest(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
+          canonicalId: getCanonicalId(skillManifest, file),
+        });
+      }
+    }
+  }
+
+  return agents;
+}
+
+async function getTasksFromBmad(scmDir, selectedModules = []) {
+  const tasks = [];
+
+  if (await fs.pathExists(path.join(scmDir, 'core', 'tasks'))) {
+    const coreTasks = await getTasksFromDir(path.join(scmDir, 'core', 'tasks'), 'core');
+    tasks.push(...coreTasks);
+  }
+
+  for (const moduleName of selectedModules) {
+    const tasksPath = path.join(scmDir, moduleName, 'tasks');
+
+    if (await fs.pathExists(tasksPath)) {
+      const moduleTasks = await getTasksFromDir(tasksPath, moduleName);
+      tasks.push(...moduleTasks);
+    }
+  }
+
+  return tasks;
+}
+
+async function getAgentsFromDir(dirPath, moduleName, relativePath = '') {
+  const agents = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return agents;
+  }
+
+  const entries = await fs.readdir(dirPath, { withFileTypes: true });
+  const skillManifest = await loadSkillManifest(dirPath);
+
+  for (const entry of entries) {
+    // Skip if entry.name is undefined or not a string
+    if (!entry.name || typeof entry.name !== 'string') {
+      continue;
+    }
+
+    const fullPath = path.join(dirPath, entry.name);
+    const newRelativePath = relativePath ? `${relativePath}/${entry.name}` : entry.name;
+
+    if (entry.isDirectory()) {
+      // Recurse into subdirectories
+      const subDirAgents = await getAgentsFromDir(fullPath, moduleName, newRelativePath);
+      agents.push(...subDirAgents);
+    } else if (entry.name.endsWith('.md')) {
+      // Skip README files and other non-agent files
+      if (entry.name.toLowerCase() === 'readme.md' || entry.name.toLowerCase().startsWith('readme-')) {
+        continue;
+      }
+
+      if (entry.name.includes('.customize.')) {
+        continue;
+      }
+
+      const content = await fs.readFile(fullPath, 'utf8');
+
+      if (content.includes('localskip="true"')) {
+        continue;
+      }
+
+      // Only include files that have agent-specific content (compiled agents have <agent> tag)
+      if (!content.includes('<agent')) {
+        continue;
+      }
+
+      agents.push({
+        path: fullPath,
+        name: entry.name.replace('.md', ''),
+        module: moduleName,
+        relativePath: newRelativePath, // Keep the .md extension for the full path
+        canonicalId: getCanonicalId(skillManifest, entry.name),
+      });
+    }
+  }
+
+  return agents;
+}
+
+async function getTasksFromDir(dirPath, moduleName) {
+  const tasks = [];
+
+  if (!(await fs.pathExists(dirPath))) {
+    return tasks;
+  }
+
+  const files = await fs.readdir(dirPath);
+  const skillManifest = await loadSkillManifest(dirPath);
+
+  for (const file of files) {
+    // Include both .md and .xml task files
+    if (!file.endsWith('.md') && !file.endsWith('.xml')) {
+      continue;
+    }
+
+    const filePath = path.join(dirPath, file);
+    const content = await fs.readFile(filePath, 'utf8');
+
+    // Skip internal/engine files (not user-facing tasks)
+    if (content.includes('internal="true"')) {
+      continue;
+    }
+
+    // Remove extension to get task name
+    const ext = file.endsWith('.xml') ? '.xml' : '.md';
+    tasks.push({
+      path: filePath,
+      name: file.replace(ext, ''),
+      module: moduleName,
+      canonicalId: getCanonicalId(skillManifest, file),
+    });
+  }
+
+  return tasks;
+}
+
+module.exports = {
+  getAgentsFromBmad,
+  getTasksFromBmad,
+  getAgentsFromDir,
+  getTasksFromDir,
+};