@clfhhc/bmad-methods-skills 0.0.2 → 0.0.3

package/bin/bmad-skills.js

@@ -79,7 +79,7 @@ async function install(args) {
     );
   }
 
-  console.log(`\n✅ Installation complete.`);
+  console.log('\n✅ Installation complete.');
 }
 
 async function init(args) {
@@ -88,6 +88,88 @@ async function init(args) {
   const toolInfo = await detectTool(args);
   if (!toolInfo) return;
 
+  // Check for bootstrap flag
+  const isBootstrap = args.includes('--bootstrap');
+
+  if (isBootstrap) {
+    console.log('🔄 Bootstrapping full BMAD suite...');
+    
+    // 1. Run conversion
+    const tempDir = '.temp/converted-skills-bootstrap';
+    console.log(`\n--- Step 1: Fetching & Converting (${tempDir}) ---`);
+    process.env.BMAD_OUTPUT_DIR = tempDir; // Pass specific output dir to convert.js
+    
+    // Create synthetic args for convert.js
+    // We filter out init-specific args to avoid confusion, but keep repo/branch overrides
+    const convertArgs = args.filter(a => 
+      !['init', '--bootstrap', '--force', '--tool'].some(x => a.includes(x))
+    );
+    
+    // Temporarily override argv for the imported module
+    const originalArgv = process.argv;
+    process.argv = [process.argv[0], process.argv[1], ...convertArgs, '--output-dir', tempDir];
+    
+    try {
+      // Import runs the main function automatically if we aren't careful?
+      // Wait, convert.js runs main() at the end. We should probably refactor convert.js to export main
+      // but simpler hack: just run it as a child process if import is messy, 
+      // OR rely on dynamic import executing top-level code.
+      // Dynamic import executes top-level code ONCE. If we imported it before, it won't run again.
+      // Safe bet: spawn a clean process.
+      const { spawn } = await import('node:child_process');
+      const binPath = fileURLToPath(import.meta.url); // this file
+      
+      await new Promise((resolve, reject) => {
+        // Run self without command -> trigger convert logic
+        const child = spawn(process.execPath, [binPath, ...convertArgs, '--output-dir', tempDir], {
+          stdio: 'inherit'
+        });
+        child.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Conversion failed with code ${code}`));
+        });
+      });
+
+    } catch (error) {
+       console.error(`❌ Bootstrap conversion failed: ${error.message}`);
+       process.argv = originalArgv; // Restore
+       return;
+    }
+    process.argv = originalArgv; // Restore
+
+    // 2. Install
+    console.log(`\n--- Step 2: Installing to ${toolInfo.name} ---`);
+    await install([
+      'install', 
+      `--from=${tempDir}`, 
+      `--tool=${toolInfo.name.toLowerCase()}`, // Ensure generic name match
+      '--force' // Always force in bootstrap mode? Or respect args? Let's use force for bootstrap convenience
+    ]);
+
+    // 3. Install bundled skills (bootstrap-bmad-skills, enhance-bmad-skills)
+    // We reuse the logic from the standard init, but silence it slightly or just run it
+    const skillsDir = path.join(pkgRoot, 'skills');
+    if (await fs.pathExists(skillsDir)) {
+      const skills = await fs.readdir(skillsDir);
+      for (const skill of skills) {
+        if ((await fs.stat(path.join(skillsDir, skill))).isDirectory()) {
+           await installSkill(skill, path.join(skillsDir, skill), path.join(process.cwd(), toolInfo.path, skill), true);
+        }
+      }
+    }
+
+    // Cleanup
+    try {
+      await fs.remove('.temp'); // Remove generic temp if used
+      // Note: we used specific temp dir, removing that
+      if (tempDir.startsWith('.temp')) await fs.remove('.temp');
+    } catch (e) { /* ignore */ }
+
+    console.log('\n✨ Bootstrap functionality complete!');
+    return;
+  }
+
+  // STANDARD INIT (Bootstrap skills only)
   console.log(`📦 Installing Bootstrap Skills for ${toolInfo.name}...`);
 
   // Dynamically find skills in package
@@ -125,7 +207,8 @@ async function init(args) {
     console.log(`\n✅ Successfully initialized in: ${toolInfo.path}/`);
     console.log('\nNext steps:');
     console.log(`1. Open your AI chat (${toolInfo.name}).`);
-    console.log('2. Type "BS" or "bootstrap-skills" to fetch and install the full BMAD method suite.');
+    console.log('2. Run "npx @clfhhc/bmad-methods-skills init --bootstrap" to auto-install everything.');
+    console.log('   OR Type "BS" in chat for the guided workflow.');
   } catch (error) {
     console.error(`\n❌ Installation failed: ${error.message}`);
   }
@@ -138,7 +221,7 @@ async function installSkill(name, source, target, force) {
   if (await fs.pathExists(target)) {
     if (!force) {
       console.warn(`  ⚠ Skill '${name}' already exists. Skipping.`);
-    console.warn('    (Use --force to overwrite)');
+      console.warn('    (Use --force to overwrite)');
       return;
     }
     console.log(`  ↻ Updating ${name}...`);
@@ -196,6 +279,7 @@ Commands:
 Options (for init/install):
   --tool=<name>    Specify tool (antigravity, cursor, claude)
   --force          Overwrite existing skills / Force installation
+  --bootstrap      Automatically fetch, convert, and install full suite
   --from=<path>    (install only) Source directory containing skills
 
 Options (for conversion):

package/convert.js

@@ -6,6 +6,7 @@ import { findAgentsAndWorkflows } from './src/utils/file-finder.js';
 import { convertAgentToSkill } from './src/converters/agent-converter.js';
 import { convertWorkflowToSkill } from './src/converters/workflow-converter.js';
 import { writeSkill } from './src/utils/skill-writer.js';
+import { migrateResources } from './src/utils/resource-migrator.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -300,7 +301,10 @@ async function main() {
       console.log();
     }
 
-    // Step 6: Generate summary
+    // Step 6: Migrate auxiliary resources
+    await migrateResources(bmadRoot, outputDir);
+
+    // Step 7: Generate summary
     await printSummary();
   } catch (error) {
     console.error(`\n❌ Fatal error: ${error.message}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clfhhc/bmad-methods-skills",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Convert BMAD-METHOD agents and workflows to Claude Skills format",
   "type": "module",
   "packageManager": "pnpm@10.28.0",

package/skills/bootstrap-bmad-skills/SKILL.md

@@ -15,52 +15,28 @@ This skill guides the user through fetching, converting, enhancing, and installi
 
 ---
 
-## Workflow
+### Step 1: Automated Bootstrap (Recommended)
+Run the automated bootstrap command to fetch, convert, and install the full BMAD method suite.
+1.  **Run**: `npx @clfhhc/bmad-methods-skills init --bootstrap`
+2.  **Verify**: Check that skills are installed in the tool directory (e.g., `.agent/skills`).
 
-### Step 1: Tool Identification
-Ask the user which tool(s) they are using. Multiple selections are allowed.
-- [ ] Claude Code
-- [ ] Cursor
-- [ ] Antigravity
-- [ ] Other (Specify)
+### Step 2: Manual Workflow (Alternative)
+If custom configuration is needed, follow these steps:
 
-### Step 2: Installation Scope
-Ask whether to install the skills as global or project-specific.
-- **Global**: Skills will be available across all projects for that tool.
-- **Project-Specific**: Skills will be limited to the current repository.
+**2.1 Fetch & Convert**
+Run `npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills` to fetch the `main` branch and convert agents/workflows.
 
-### Step 3: Fetch & Convert
-Inform the user that you will now fetch the `bmad-methods` main branch and convert it in a temporary folder.
+**2.2 Apply Enhancements**
+1.  **Scan Paths**: Check for `{project-root}` references.
+2.  **Adapt Paths**: Adjust paths for your specific installation scope.
 
-1.  **Convert**: Run `npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills`
-    - This fetches the `main` branch of BMAD-METHOD and converts all agents/workflows.
+**2.3 Install Skills**
+Run the `install` command to move skills to their final destination.
+- Run `npx @clfhhc/bmad-methods-skills install --from .temp/converted-skills --tool [TOOL] --force`
+  - Replace `[TOOL]` with `antigravity`, `cursor`, or `claude`.
 
-### Step 4: Apply Enhancements
-Apply Phase 2 path adaptations and Phase 3 meta-docs.
-
-1.  **Scan Paths**: Use the `enhance-bmad-skills` (`SP`) command to scan the converted skills for `{project-root}` references.
-2.  **Adapt Paths**: Propose path adaptations (relative vs absolute) based on the target installation type.
-    - If **Global**: Prefer absolute paths or relative to a fixed global root.
-    - If **Project-Specific**: Prefer relative paths within the project.
-
-### Step 5: Install Skills
-Run the `install` command to move the enhanced skills to their final destination.
-
-1.  **Install**: Run `npx @clfhhc/bmad-methods-skills install --from .temp/converted-skills --tool [TOOL] --force`
-    - Replace `[TOOL]` with `antigravity`, `cursor`, or `claude`.
-    - Use `--force` to overwrite if you are sure.
-
-| Tool | Scope | Destination |
-|------|-------|-------------|
-| **Claude Code** | Global | `~/.claude/skills/` |
-| **Claude Code** | Local | `./.claude/skills/` |
-| **Cursor** | Local | `./.cursor/skills/` |
-| **Antigravity** | Local | `./.agent/skills/` |
-
-*Note: The CLI will handle directory creation and copying.*
-
-### Step 6: Verify
-Ensure all file paths in the `SKILL.md` files are correct and that any referenced `data/` or `knowledge/` folders were moved correctly.
+### Step 3: Verify
+Ensure all file paths in the `SKILL.md` files are correct and that `data/` or `knowledge/` folders were moved correctly (automated in Step 1).
 
 ---
 

package/src/utils/path-rewriter.js

@@ -148,6 +148,17 @@ export function rewriteBmadPaths(content, _currentModule = 'bmm') {
     `${relativePrefix}/bmm/tea/tea-index.csv`
   );
 
+  // Rewrite documentation-standards.md references (migrated to tech-writer/data)
+  // {project-root}/_bmad/bmm/data/documentation-standards.md -> ../../bmm/tech-writer/data/documentation-standards.md
+  // But wait, if we are IN tech-writer, it should be ./data/documentation-standards.md
+  // The relativePrefix logic handles ../.. but we might prefer a direct replacement here 
+  // since it's a specific file. 
+  // Let's rely on the generic ../..bmm/tech-writer/data approach which works from anywhere.
+  result = result.replace(
+    /\{project-root\}\/_bmad\/bmm\/data\/documentation-standards\.md/g,
+    `${relativePrefix}/bmm/tech-writer/data/documentation-standards.md`
+  );
+
   // Rewrite _memory sidecar references (these are runtime, mark as placeholder)
   result = result.replace(
     /\{project-root\}\/_bmad\/_memory\/([^/\s'"]+)/g,

package/src/utils/resource-migrator.js

@@ -0,0 +1,65 @@
+import fs from 'fs-extra';
+import path from 'node:path';
+
+/**
+ * Migrates specific data and knowledge resources from BMAD repo to skills output
+ * @param {string} bmadRoot - Root of the fetched BMAD repo
+ * @param {string} outputDir - Root of the skills output directory
+ */
+export async function migrateResources(bmadRoot, outputDir) {
+  console.log('📦 Migrating auxiliary resources...');
+
+  const migrations = [
+    {
+      // Tech Writer: documentation-standards.md
+      // From: src/modules/bmm/data/documentation-standards.md
+      // To: bmm/tech-writer/data/documentation-standards.md
+      src: path.join('src', 'modules', 'bmm', 'data', 'documentation-standards.md'),
+      dest: path.join('bmm', 'tech-writer', 'data', 'documentation-standards.md'),
+      name: 'Documentation Standards',
+    },
+    {
+      // TEA: tea-index.csv
+      // From: src/modules/bmm/testarch/tea-index.csv
+      // To: bmm/tea/tea-index.csv
+      src: path.join('src', 'modules', 'bmm', 'testarch', 'tea-index.csv'),
+      dest: path.join('bmm', 'tea', 'tea-index.csv'),
+      name: 'TEA Index',
+    },
+    {
+      // TEA: knowledge directory
+      // From: src/modules/bmm/testarch/knowledge/
+      // To: bmm/tea/knowledge/
+      src: path.join('src', 'modules', 'bmm', 'testarch', 'knowledge'),
+      dest: path.join('bmm', 'tea', 'knowledge'),
+      name: 'TEA Knowledge Base',
+      isDirectory: true,
+    }
+  ];
+
+  let migratedCount = 0;
+
+  for (const migration of migrations) {
+    try {
+      const srcPath = path.join(bmadRoot, migration.src);
+      const destPath = path.join(outputDir, migration.dest);
+
+      if (await fs.pathExists(srcPath)) {
+        await fs.ensureDir(path.dirname(destPath));
+        await fs.copy(srcPath, destPath, { overwrite: true });
+        console.log(`  ✓ Migrated ${migration.name}`);
+        migratedCount++;
+      } else {
+        console.warn(`  ⚠️  Source not found for ${migration.name}: ${migration.src}`);
+      }
+    } catch (error) {
+      console.error(`  ✗ Failed to migrate ${migration.name}: ${error.message}`);
+    }
+  }
+
+  console.log(`  ✓ Migrated ${migratedCount} resources\n`);
+  if (migratedCount < migrations.length) {
+    console.warn('  ⚠️  Some resources were not found. This may happen if the BMAD repository structure has changed.');
+    console.warn('      Please check if a newer version of @clfhhc/bmad-methods-skills is available.');
+  }
+}