bmad-module-skill-forge 0.9.0 → 0.10.1-alpha.0

package/tools/cli/lib/ide-skills.js

@@ -0,0 +1,216 @@
+/**
+ * IDE Skill Installer — Verbatim skill directory installation
+ *
+ * Replaces the legacy command-file generation approach with the BMAD standard:
+ * skill directories (containing SKILL.md + supporting files) are copied directly
+ * to each IDE's skills/ directory. IDEs read SKILL.md natively.
+ *
+ * Supports 23+ IDEs via platform-codes.yaml (config-driven, no IDE-specific code).
+ */
+
+const path = require('node:path');
+const fs = require('fs-extra');
+const yaml = require('js-yaml');
+
+const PLATFORM_CODES_PATH = path.join(__dirname, 'platform-codes.yaml');
+
+// OS/editor artifacts to filter during copy
+const ARTIFACT_FILTER = new Set(['.DS_Store', 'Thumbs.db', 'desktop.ini', '._.DS_Store']);
+
+/**
+ * Load platform configuration from platform-codes.yaml.
+ * Returns { platforms: { 'claude-code': { name, preferred, installer: { target_dir, legacy_targets } }, ... } }
+ */
+function loadPlatforms() {
+  const content = fs.readFileSync(PLATFORM_CODES_PATH, 'utf8');
+  return yaml.load(content);
+}
+
+/**
+ * Get available platforms for UI display.
+ * Returns array of { value, label, preferred, skillInvocationPrefix }.
+ * skillInvocationPrefix is null when the IDE only auto-invokes skills.
+ */
+function getAvailablePlatforms() {
+  const config = loadPlatforms();
+  return Object.entries(config.platforms)
+    .filter(([, p]) => !p.suspended)
+    .map(([code, p]) => ({
+      value: code,
+      label: p.name,
+      preferred: p.preferred || false,
+      skillInvocationPrefix: p.skill_invocation_prefix ?? null,
+    }))
+    .sort((a, b) => {
+      // Preferred first, then alphabetical
+      if (a.preferred !== b.preferred) return b.preferred ? 1 : -1;
+      return a.label.localeCompare(b.label);
+    });
+}
+
+/**
+ * Get IDE auto-detection markers.
+ * Returns { 'claude-code': ['.claude'], 'cursor': ['.cursor'], ... }
+ *
+ * Uses explicit detection_marker from platform config when available,
+ * otherwise derives from the top-level directory of target_dir.
+ * The derived marker only works when the IDE's config directory exists
+ * independently of the installer (e.g. .claude/ exists before SKF install).
+ */
+function getDetectionMarkers() {
+  const config = loadPlatforms();
+  const markers = {};
+  for (const [code, p] of Object.entries(config.platforms)) {
+    if (p.suspended) continue;
+    const targetDir = p.installer?.target_dir;
+    if (!targetDir) continue;
+    if (p.installer.detection_marker) {
+      markers[code] = [p.installer.detection_marker];
+    } else {
+      // Derive from target_dir — works when top-level dir is the IDE's own config dir
+      const topDir = '.' + targetDir.split('/')[0].replace(/^\./, '');
+      markers[code] = [topDir];
+    }
+  }
+  return markers;
+}
+
+/**
+ * Install skill directories to all selected IDEs.
+ *
+ * @param {string} projectDir - Project root directory
+ * @param {string} skfDir - Path to installed SKF module (e.g., {projectDir}/_bmad/skf)
+ * @param {string[]} ideCodes - Array of IDE codes (e.g., ['claude-code', 'cursor'])
+ * @returns {{ installed: number, ides: string[], directories: string[] }}
+ */
+async function installSkillsToIdes(projectDir, skfDir, ideCodes) {
+  if (!ideCodes || ideCodes.length === 0) return { installed: 0, ides: [], directories: [] };
+
+  const config = loadPlatforms();
+  let totalInstalled = 0;
+  const processedIdes = [];
+  const allDirectories = [];
+
+  // Copy filter: skip OS artifacts
+  const copyFilter = (src) => !ARTIFACT_FILTER.has(path.basename(src));
+
+  for (const ideCode of ideCodes) {
+    const platform = config.platforms[ideCode];
+    if (!platform || !platform.installer?.target_dir) continue;
+
+    const targetDir = path.join(projectDir, platform.installer.target_dir);
+
+    // Clean legacy targets first (old command files from previous SKF installs)
+    await cleanLegacyTargets(projectDir, platform);
+
+    // Clean existing SKF skills from this IDE (for update/reinstall)
+    await cleanSkfSkills(targetDir);
+
+    // Ensure target directory exists
+    await fs.ensureDir(targetDir);
+
+    // Copy all skf-* skill directories from the installed module
+    if (await fs.pathExists(skfDir)) {
+      const entries = await fs.readdir(skfDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+
+        // Copy skill directories (skf-*) and supporting resources (knowledge/, shared/)
+        if (entry.name.startsWith('skf-') || entry.name === 'knowledge' || entry.name === 'shared') {
+          const src = path.join(skfDir, entry.name);
+          const dest = path.join(targetDir, entry.name);
+          await fs.copy(src, dest, { filter: copyFilter });
+          totalInstalled++;
+        }
+      }
+    }
+
+    allDirectories.push(platform.installer.target_dir);
+    processedIdes.push(ideCode);
+  }
+
+  return { installed: totalInstalled, ides: processedIdes, directories: allDirectories };
+}
+
+/**
+ * Remove legacy command files from old IDE target directories.
+ * Handles migration from command-file approach to skill-directory approach.
+ */
+async function cleanLegacyTargets(projectDir, platform) {
+  const legacyTargets = platform.installer?.legacy_targets || [];
+
+  for (const legacyDir of legacyTargets) {
+    const fullPath = path.join(projectDir, legacyDir);
+    if (!(await fs.pathExists(fullPath))) continue;
+
+    try {
+      const files = await fs.readdir(fullPath);
+      for (const file of files) {
+        // Remove SKF-specific command files from legacy directories
+        if (file.startsWith('bmad-skf-') || file.startsWith('bmad-agent-skf-')) {
+          await fs.remove(path.join(fullPath, file));
+        }
+      }
+
+      // Remove empty directories
+      const remaining = await fs.readdir(fullPath);
+      if (remaining.length === 0) {
+        await fs.remove(fullPath);
+        // Also try to remove empty parent
+        const parentDir = path.dirname(fullPath);
+        try {
+          const parentRemaining = await fs.readdir(parentDir);
+          if (parentRemaining.length === 0) await fs.remove(parentDir);
+        } catch {
+          /* ignore */
+        }
+      }
+    } catch {
+      /* non-critical, continue */
+    }
+  }
+}
+
+/**
+ * Remove existing SKF skill directories from an IDE target.
+ * Called before reinstalling to ensure clean state.
+ */
+async function cleanSkfSkills(targetDir) {
+  if (!(await fs.pathExists(targetDir))) return;
+
+  try {
+    const entries = await fs.readdir(targetDir);
+    for (const entry of entries) {
+      // Only remove SKF-owned directories (skf-*, knowledge, shared)
+      if (entry.startsWith('skf-') || entry === 'knowledge' || entry === 'shared') {
+        await fs.remove(path.join(targetDir, entry));
+      }
+    }
+  } catch {
+    /* non-critical */
+  }
+}
+
+/**
+ * Remove all SKF skills from all known IDE directories.
+ * Used during uninstall.
+ */
+async function removeAllSkfSkills(projectDir) {
+  const config = loadPlatforms();
+  const removed = [];
+
+  for (const [, platform] of Object.entries(config.platforms)) {
+    if (!platform.installer?.target_dir) continue;
+    const targetDir = path.join(projectDir, platform.installer.target_dir);
+    if (await fs.pathExists(targetDir)) {
+      await cleanSkfSkills(targetDir);
+      // Also clean legacy targets
+      await cleanLegacyTargets(projectDir, platform);
+      removed.push(platform.installer.target_dir);
+    }
+  }
+
+  return removed;
+}
+
+module.exports = { installSkillsToIdes, getAvailablePlatforms, getDetectionMarkers, removeAllSkfSkills, loadPlatforms };

package/tools/cli/lib/installer.js

@@ -1,14 +1,13 @@
 /**
  * SKF Installer - Core orchestrator
- * Copies SKF source files, compiles agents, creates folder structure.
+ * Copies SKF source files, installs skills to IDEs, creates folder structure.
  */
 
 const path = require('node:path');
 const fs = require('fs-extra');
 const { spinner } = require('@clack/prompts');
 const yaml = require('js-yaml');
-const { compileAgentFile } = require('./compiler');
-const { generateIdeCommands } = require('./ide-commands');
+const { installSkillsToIdes } = require('./ide-skills');
 const { writeManifest } = require('./manifest');
 
 class Installer {
@@ -39,6 +38,7 @@ class Installer {
           if (!config.ides && savedData.ides) config.ides = savedData.ides;
           if (!config.skills_output_folder && savedData.skills_output_folder) config.skills_output_folder = savedData.skills_output_folder;
           if (!config.forge_data_folder && savedData.forge_data_folder) config.forge_data_folder = savedData.forge_data_folder;
+          if (config.install_learning == null && savedData.install_learning != null) config.install_learning = savedData.install_learning;
         } catch {
           /* ignore parse errors, defaults will apply */
         }
@@ -89,17 +89,7 @@ class Installer {
       throw error;
     }
 
-    // Step 4: Compile agents
-    s.start('Compiling agents...');
-    try {
-      const agents = await this.compileAgents(skfDir, skfFolder);
-      s.stop(`Compiled ${agents.length} agent${agents.length === 1 ? '' : 's'}`);
-    } catch (error) {
-      s.stop('Failed to compile agents');
-      throw error;
-    }
-
-    // Step 5: Create output folders
+    // Step 4: Create output folders
     s.start('Creating project folders...');
     try {
       await this.createOutputFolders(projectDir, config);
@@ -109,7 +99,7 @@ class Installer {
       throw error;
     }
 
-    // Step 6: Copy learning material (optional)
+    // Step 5: Copy learning material (optional)
     if (config.install_learning !== false) {
       s.start('Copying learning & reference material...');
       try {
@@ -121,32 +111,32 @@ class Installer {
       }
     }
 
-    // Step 7: Generate IDE command files
-    let ideFiles = [];
+    // Step 6: Install skills to selected IDEs
+    let ideDirectories = [];
     const selectedIdes = config.ides || [];
-    if (selectedIdes.length > 0 && !selectedIdes.every((ide) => ide === 'other')) {
-      s.start('Generating IDE commands...');
+    if (selectedIdes.length > 0) {
+      s.start('Installing skills to IDEs...');
       try {
-        const ideResult = await generateIdeCommands(projectDir, skfFolder, selectedIdes);
-        ideFiles = ideResult.files || [];
-        if (ideResult.generated > 0) {
-          s.stop(`IDE commands generated for ${ideResult.ides.join(', ')}`);
+        const ideResult = await installSkillsToIdes(projectDir, skfDir, selectedIdes);
+        ideDirectories = ideResult.directories || [];
+        if (ideResult.installed > 0) {
+          s.stop(`Skills installed for ${ideResult.ides.join(', ')}`);
         } else {
-          s.stop('No IDE commands to generate');
+          s.stop('No IDE skill installation needed');
         }
       } catch (error) {
-        s.stop('Failed to generate IDE commands');
+        s.stop('Failed to install skills to IDEs');
         throw error;
       }
     }
 
-    // Step 8: Write installation manifest
+    // Step 7: Write installation manifest
     s.start('Writing manifest...');
     try {
       const packageJson = require('../../../package.json');
       await writeManifest(projectDir, config, {
         version: packageJson.version,
-        ideFiles,
+        ideDirectories,
       });
       s.stop('Installation manifest saved');
     } catch (error) {
@@ -159,11 +149,19 @@ class Installer {
 
   /**
    * Copy src/ content into the target SKF directory.
-   * Workflows are placed under a skillforge/ subdirectory to match agent path references.
+   * Skill directories (skf-*) are copied flat alongside module-level resources.
    */
   async copySrcFiles(skfDir) {
-    // Copy agents and knowledge directly
-    for (const dir of ['agents', 'knowledge']) {
+    // Copy skill directories (skf-*) — each is a self-contained skill
+    const srcEntries = await fs.readdir(this.srcDir, { withFileTypes: true });
+    for (const entry of srcEntries) {
+      if (entry.isDirectory() && entry.name.startsWith('skf-')) {
+        await fs.copy(path.join(this.srcDir, entry.name), path.join(skfDir, entry.name));
+      }
+    }
+
+    // Copy module-level resources
+    for (const dir of ['knowledge', 'shared']) {
       const src = path.join(this.srcDir, dir);
       const dest = path.join(skfDir, dir);
       if (await fs.pathExists(src)) {
@@ -171,13 +169,6 @@ class Installer {
       }
     }
 
-    // Workflows go under workflows/skillforge/ to match agent YAML paths
-    const workflowsSrc = path.join(this.srcDir, 'workflows');
-    const workflowsDest = path.join(skfDir, 'workflows', 'skillforge');
-    if (await fs.pathExists(workflowsSrc)) {
-      await fs.copy(workflowsSrc, workflowsDest);
-    }
-
     // Copy module.yaml and module-help.csv
     for (const file of ['module.yaml', 'module-help.csv']) {
       const src = path.join(this.srcDir, file);
@@ -241,27 +232,13 @@ class Installer {
       sidecar_path: '_bmad/_memory/forger-sidecar',
       skf_folder: config.skfFolder,
       ides: config.ides || [],
+      install_learning: config.install_learning !== false,
     };
 
     const yamlStr = yaml.dump(configData, { lineWidth: -1 });
     await fs.writeFile(path.join(skfDir, 'config.yaml'), `# SKF Configuration - Generated by installer\n${yamlStr}`, 'utf8');
   }
 
-  async compileAgents(skfDir, skfFolder) {
-    const agentsDir = path.join(skfDir, 'agents');
-    const files = await fs.readdir(agentsDir);
-    const agentFiles = files.filter((f) => f.endsWith('.agent.yaml'));
-    const results = [];
-
-    for (const file of agentFiles) {
-      const yamlPath = path.join(agentsDir, file);
-      const result = compileAgentFile(yamlPath, { skfFolder });
-      results.push(result);
-    }
-
-    return results;
-  }
-
   async createOutputFolders(projectDir, config) {
     const skillsFolder = config.skills_output_folder || 'skills';
     const forgeDataFolder = config.forge_data_folder || 'forge-data';

package/tools/cli/lib/manifest.js

@@ -36,7 +36,7 @@ async function collectFiles(dir, projectDir) {
  *
  * @param {string} projectDir - Project root
  * @param {object} config - Install config (skfFolder, ides, etc.)
- * @param {object} options - Additional info (version, ideFiles)
+ * @param {object} options - Additional info (version, ideDirectories)
  */
 async function writeManifest(projectDir, config, options = {}) {
   const skfFolder = config.skfFolder || '_bmad/skf';
@@ -47,8 +47,14 @@ async function writeManifest(projectDir, config, options = {}) {
   const skfFiles = await collectFiles(skfDir, projectDir);
   const sidecarFiles = await collectFiles(sidecarDir, projectDir);
 
-  // Collect IDE command files
-  const ideFiles = options.ideFiles || [];
+  // Collect IDE skill directory files (installed to each IDE's skills/ dir)
+  const ideDirectories = options.ideDirectories || [];
+  const ideSkillFiles = [];
+  for (const ideDir of ideDirectories) {
+    const fullDir = path.join(projectDir, ideDir);
+    const files = await collectFiles(fullDir, projectDir);
+    ideSkillFiles.push(...files);
+  }
 
   // Collect learning material files
   const learnDir = path.join(projectDir, '_skf-learn');
@@ -72,11 +78,11 @@ async function writeManifest(projectDir, config, options = {}) {
     ides: config.ides || [],
     skills_output_folder: config.skills_output_folder || 'skills',
     forge_data_folder: config.forge_data_folder || 'forge-data',
-    directories: [skfFolder, '_bmad/_memory/forger-sidecar', ...(learnFiles.length > 0 ? ['_skf-learn'] : [])],
+    directories: [skfFolder, '_bmad/_memory/forger-sidecar', ...ideDirectories, ...(learnFiles.length > 0 ? ['_skf-learn'] : [])],
     files: {
       skf: skfFiles,
       sidecar: sidecarFiles,
-      ide_commands: ideFiles,
+      ide_skills: ideSkillFiles,
       learning: learnFiles,
       output: outputFiles,
     },

package/tools/cli/lib/platform-codes.yaml

@@ -0,0 +1,223 @@
+# BMAD Platform Codes Configuration
+#
+# Each platform entry has:
+#   name: Display name shown to users
+#   preferred: Whether shown as a recommended option on install
+#   suspended: (optional) Message explaining why install is blocked
+#   skill_invocation_prefix: (optional) Prefix users type to invoke a named
+#     skill in this IDE's chat. Examples:
+#       "/"        — slash command, e.g. /skf-forger (most IDEs)
+#       "$"        — dollar mention, e.g. $skf-forger (Codex)
+#       "/skill:"  — namespaced slash, e.g. /skill:skf-forger (Pi)
+#     Omit when the IDE only auto-invokes skills from descriptions and has
+#     no manual invocation form (Cline, GitHub Copilot, Junie, etc.).
+#   installer:
+#     target_dir: Directory where skill directories are installed
+#     legacy_targets: (optional) Old target dirs to clean up on reinstall
+platforms:
+  antigravity:
+    name: "Google Antigravity"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      detection_marker: .agent/antigravity
+      legacy_targets:
+        - .agent/workflows
+      target_dir: .agent/skills
+
+  auggie:
+    name: "Auggie"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .augment/commands
+      target_dir: .augment/skills
+
+  claude-code:
+    name: "Claude Code"
+    preferred: true
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .claude/commands
+      target_dir: .claude/skills
+
+  cline:
+    name: "Cline"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      detection_marker: .clinerules
+      legacy_targets:
+        - .clinerules/workflows
+      target_dir: .cline/skills
+
+  codex:
+    name: "Codex"
+    preferred: false
+    skill_invocation_prefix: "$"
+    installer:
+      detection_marker: .codex
+      legacy_targets:
+        - .codex/prompts
+      target_dir: .agents/skills
+
+  codebuddy:
+    name: "CodeBuddy"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .codebuddy/commands
+      target_dir: .codebuddy/skills
+
+  crush:
+    name: "Crush"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      legacy_targets:
+        - .crush/commands
+      target_dir: .crush/skills
+
+  cursor:
+    name: "Cursor"
+    preferred: true
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .cursor/commands
+      target_dir: .cursor/skills
+
+  gemini:
+    name: "Gemini CLI"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .gemini/commands
+      target_dir: .gemini/skills
+
+  github-copilot:
+    name: "GitHub Copilot"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      detection_marker: .github/copilot-instructions.md
+      legacy_targets:
+        - .github/agents
+        - .github/prompts
+      target_dir: .github/skills
+
+  iflow:
+    name: "iFlow"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .iflow/commands
+      target_dir: .iflow/skills
+
+  junie:
+    name: "Junie"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      target_dir: .junie/skills
+
+  kilo:
+    name: "KiloCoder"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      legacy_targets:
+        - .kilocode/workflows
+      target_dir: .kilocode/skills
+
+  kiro:
+    name: "Kiro"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      legacy_targets:
+        - .kiro/steering
+      target_dir: .kiro/skills
+
+  ona:
+    name: "Ona"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      target_dir: .ona/skills
+
+  opencode:
+    name: "OpenCode"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .opencode/agents
+        - .opencode/commands
+        - .opencode/agent
+        - .opencode/command
+      target_dir: .opencode/skills
+
+  pi:
+    name: "Pi"
+    preferred: false
+    skill_invocation_prefix: "/skill:"
+    installer:
+      target_dir: .pi/skills
+
+  qoder:
+    name: "Qoder"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      target_dir: .qoder/skills
+
+  qwen:
+    name: "QwenCoder"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .qwen/commands
+      target_dir: .qwen/skills
+
+  roo:
+    name: "Roo Code"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .roo/commands
+      target_dir: .roo/skills
+
+  rovo-dev:
+    name: "Rovo Dev"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      legacy_targets:
+        - .rovodev/workflows
+      target_dir: .rovodev/skills
+
+  trae:
+    name: "Trae"
+    preferred: false
+    # Auto-invoked from descriptions; no manual prefix
+    installer:
+      legacy_targets:
+        - .trae/rules
+      target_dir: .trae/skills
+
+  windsurf:
+    name: "Windsurf"
+    preferred: false
+    skill_invocation_prefix: "/"
+    installer:
+      legacy_targets:
+        - .windsurf/workflows
+      target_dir: .windsurf/skills