@clfhhc/bmad-methods-skills 0.3.1 → 0.3.2

package/README.md

@@ -17,7 +17,12 @@ pnpm dlx @clfhhc/bmad-methods-skills init
 
 This installs `bootstrap-bmad-skills` and `enhance-bmad-skills`. Then open your AI tool and use the **`BS`** command to start the guided installation workflow.
 
-> **Note:** For fully automated installation without prompts, use `init --bootstrap` instead.
+> **Note:** For fully automated installation without prompts, run the conversion and installation commands together (and cleanup):
+```bash
+npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills && \
+npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --force && \
+rm -rf .temp
+```
 
 ## What It Does
 

package/config.json

@@ -6,6 +6,78 @@
   "modules": ["bmm", "core"],
   "outputStructure": "flat",
   "sourcePathPrefixesToStrip": ["src/modules/", "src/"],
+  "configHeaderTemplate": "# {{moduleName}} Module Configuration\n# Generated by BMAD Skills Converter\n# Date: {{date}}\n#\n# Customize these values for your project.\n# Run the bootstrap-bmad-skills skill for guided configuration.\n\n",
+  "workflowParsing": {
+    "frontmatterRegex": "^---\\s*\\n([\\s\\S]*?)\\n---\\s*\\n([\\s\\S]*)$",
+    "markdownHeadingRegex": "^(#+)",
+    "xmlNameAttributeRegex": "name=\"([^\"]+)\"",
+    "xmlStandaloneAttributeRegex": "standalone=\"([^\"]+)\"",
+    "taskTagRegex": "<task\\s+([^>]+)>",
+    "llmCriticalTagRegex": "<llm\\s+critical=\"true\">([\\s\\S]*?)<\\/llm>",
+    "integrationTagRegex": "<integration\\s+description=\"([^\"]+)\">([\\s\\S]*?)<\\/integration>",
+    "stepTagRegex": "<step\\s+n=\"(\\d+)\"(?:\\s+title=\"([^\"]+)\")?(?:\\s+goal=\"([^\"]+)\")?[^>]*>",
+    "caseTagRegex": "<case\\s+n=\"([^\"]+)\">([\\s\\S]*?)<\\/case>",
+    "descTagRegex": "<desc>([^<]+)<\\/desc>",
+    "instructionItemTagRegex": "<i>([\\s\\S]*?)<\\/i>",
+    "actionTagRegex": "<action>([^<]+)<\\/action>",
+    "askTagRegex": "<ask>([^<]+)<\\/ask>",
+    "criticalTagRegex": "<critical>([^<]+)<\\/critical>",
+    "outputTagRegex": "<output>([^<]+)<\\/output>",
+    "checkIfTagRegex": "<check\\s+if=\"([^\"]+)\">([\\s\\S]*?)<\\/check>",
+    "gotoAnchorTagRegex": "<goto\\s+anchor=\"([^\"]+)\"\\s*\\/>",
+    "invokeWorkflowTagRegex": "<invoke-workflow>([^<]+)<\\/invoke-workflow>",
+    "templateOutputTagRegex": "<template-output>([^<]+)<\\/template-output>",
+    "anyTagRegex": "<[^>]+>",
+    "multipleNewlinesRegex": "\\n{3,}",
+    "markdownStepTagRegex": "<step\\s+n=\"(\\d+)\"(?:\\s+goal=\"([^\"]+)\")?>",
+    "markdownAskTagRegex": "<ask>(.*?)<\\/ask>",
+    "markdownActionTagRegex": "<action>(.*?)<\\/action>",
+    "markdownCheckTagRegex": "<check>(.*?)<\\/check>",
+    "markdownInvokeWorkflowTagRegex": "<invoke-workflow>(.*?)<\\/invoke-workflow>",
+    "markdownTemplateOutputTagRegex": "<template-output>(.*?)<\\/template-output>",
+    "taskCloseTagRegex": "<\\/task>",
+    "llmOpenTagRegex": "<llm[^>]*>",
+    "llmCloseTagRegex": "<\\/llm>",
+    "flowOpenTagRegex": "<flow>",
+    "flowCloseTagRegex": "<\\/flow>",
+    "stepCloseTagRegex": "<\\/step>",
+    "checkCloseTagRegex": "<\\/check>",
+    "whitespaceRegex": "\\s+",
+    "frontmatterSimpleRegex": "^---\\s*\\n([\\s\\S]*?)\\n---",
+    "xmlNameRegex": "name=\"([^\"]+)\"",
+    "namedSections": [
+      "csv-structure",
+      "context-analysis",
+      "smart-selection",
+      "format",
+      "response-handling",
+      "validation",
+      "critical-context",
+      "halt-conditions"
+    ],
+    "sectionRegexTemplate": "<{{section}}[^>]*>([\\s\\S]*?)<\\/{{section}}>",
+    "sectionTemplatePlaceholderRegex": "{{section}}"
+  },
+  "agentParsing": {
+    "principleLineRegex": "^-\\s*['\"]?",
+    "principleTrailingQuoteRegex": "['\"]\\s*$",
+    "triggerSanitizationRegex": "\\s+",
+    "workflowCodeRegex": "\\[(\\w+)\\]",
+    "workflowCodeGlobalRegex": "\\[(\\w+)\\]/g",
+    "bracketRemovalRegex": "[[\\]]",
+    "hyphenRegex": "-",
+    "underscoreRegex": "_"
+  },
+  "sanitization": {
+    "invalidCharsRegex": "[^a-z0-9-]",
+    "multipleHyphensRegex": "-+",
+    "leadingTrailingHyphensRegex": "^-|-$",
+    "trailingHyphensRegex": "-+$"
+  },
+  "fallbackModuleExtractionPatterns": [
+    { "pattern": "^src\\/modules\\/([^/]+)\\/", "group": 1 },
+    { "pattern": "^src\\/([^/]+)\\/", "group": 1 }
+  ],
   "moduleExtractionPatterns": [
     { "pattern": "^src\\/modules\\/([^/]+)\\/", "group": 1 },
     { "pattern": "^src\\/([^/]+)\\/", "group": 1 }
@@ -59,7 +131,9 @@
   ],
   "skillMap": {
     "sourcePrefix": "\\{project-root\\}/_bmad/",
-    "dirLookahead": "(?=['\\s`]|$)",
+    "dirLookahead": "(?=['\\s`/]|$)",
+    "fileLookahead": "(?=['\\s`]|$)",
+    "escapedPathRegex": "[.*+?^${}()|[\\]\\\\]",
     "replacementPrefix": "{skill-root}"
   },
   "pathPatterns": [

package/convert.js

@@ -58,14 +58,13 @@ output_folder: "_bmad-output"
  * @returns {Promise<string>} YAML config content
  */
 async function getModuleConfigContent(moduleName, bmadRoot = null) {
-  const header = `# ${moduleName.toUpperCase()} Module Configuration
-# Generated by BMAD Skills Converter
-# Date: ${new Date().toISOString()}
-#
-# Customize these values for your project.
-# Run the bootstrap-bmad-skills skill for guided configuration.
+  const headerTemplate =
+    config.configHeaderTemplate ||
+    `# ${moduleName.toUpperCase()} Module Configuration\n# Generated by BMAD Skills Converter\n# Date: ${new Date().toISOString()}\n#\n# Customize these values for your project.\n# Run the bootstrap-bmad-skills skill for guided configuration.\n\n`;
 
-`;
+  const header = headerTemplate
+    .replace('{{moduleName}}', moduleName.toUpperCase())
+    .replace('{{date}}', new Date().toISOString());
 
   // Try to load config template from BMAD repo
   if (bmadRoot) {
@@ -402,7 +401,12 @@ async function main() {
       bmadRoot,
       config.agentPaths,
       config.workflowPaths,
-      { moduleExtractionPatterns: config.moduleExtractionPatterns }
+      {
+        moduleExtractionPatterns: config.moduleExtractionPatterns,
+        fallbackModuleExtractionPatterns:
+          config.fallbackModuleExtractionPatterns,
+        workflowParsingPatterns: config.workflowParsing || {},
+      }
     );
 
     stats.agents.total = agents.length;
@@ -466,6 +470,7 @@ async function main() {
         identityCharLimit: config.enhancements.identityCharLimit ?? null,
         allAgents: agents,
         allWorkflows: workflows,
+        parsingPatterns: config.agentParsing || {},
       };
       for (const agent of agents) {
         try {
@@ -497,7 +502,9 @@ async function main() {
     // Step 5: Convert workflows
     if (workflows.length > 0) {
       console.log('⚙️  Converting workflows...');
-      const workflowOptions = {};
+      const workflowOptions = {
+        parsingPatterns: config.workflowParsing || {},
+      };
       for (const workflow of workflows) {
         try {
           const skillContent = await convertWorkflowToSkill(

package/docs/getting-started.md

@@ -14,13 +14,21 @@ This tool converts BMAD-METHOD (Breakthrough Method for Agile AI-Driven Developm
 
 ### Option A: One-Liner (Recommended)
 
-The fastest way to get all BMAD skills installed:
+The fastest way to get all BMAD skills installed (auto-detects tool):
 
 ```bash
-npx @clfhhc/bmad-methods-skills init --tool=[TOOL] --bootstrap
+npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills && \
+npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --force && \
+rm -rf .temp
 ```
 
-Replace `[TOOL]` with `antigravity`, `cursor`, or `claude`.
+For a specific tool (e.g., Cursor):
+
+```bash
+npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills && \
+npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --tool=cursor --force && \
+rm -rf .temp
+```
 
 This single command:
 1. ✅ Fetches and converts all BMAD agents/workflows
@@ -52,7 +60,7 @@ The `BS` command starts an AI-guided workflow that:
 2. Asks if you want global or project-specific installation
 3. Walks you through custom configuration options
 
-> **Note**: The `BS` workflow now recommends using `--bootstrap` for the actual installation.
+> **Note**: The `BS` workflow now uses a unified conversion and installation process.
 
 ## Prerequisites
 
@@ -222,7 +230,6 @@ pnpm clean:all
 |---------|-------------|
 | `npx @clfhhc/bmad-methods-skills` | Run the converter (fetch + convert) |
 | `npx @clfhhc/bmad-methods-skills init` | Install bootstrap skills only |
-| `npx @clfhhc/bmad-methods-skills init --bootstrap` | **Full install**: fetch, convert, and install |
 | `npx @clfhhc/bmad-methods-skills install --from=<path>` | Install from a local directory |
 
 ### Init Options
@@ -230,5 +237,4 @@ pnpm clean:all
 | Option | Description |
 |--------|-------------|
 | `--tool=<name>` | Target tool: `antigravity`, `cursor`, or `claude` |
-| `--bootstrap` | Auto-fetch, convert, and install the full BMAD suite |
 | `--force` | Overwrite existing skills |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clfhhc/bmad-methods-skills",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Convert BMAD-METHOD agents and workflows to Claude Skills format",
   "type": "module",
   "repository": {

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

@@ -13,112 +13,153 @@ description: Bootstrap and install BMAD-METHOD skills for Claude Code, Cursor, A
 
 ## When You Run BS (Guided Flow)
 
-For **`BS`** or **`bootstrap-skills`**: (1) Ask Step 1 (Tool), Step 2 (Scope), and **Configure Installation**—offer defaults. (2) Summarize and **confirm** before running commands. (3) Run the one-liner or Manual (Steps 3–5) as appropriate; write the user’s config to `{skill-root}/_config/core.yaml` and `{skill-root}/_config/bmm.yaml` after install.
+Follow these phases in order. The SAME steps apply whether installing to 1 tool or multiple tools.
 
----
-
-## Quick Start (Unattended)
+### Phase 1: Gather Information
 
-Use only when the user explicitly wants to **skip prompts** (e.g. “just run it” or “use defaults”):
-
-```bash
-npx @clfhhc/bmad-methods-skills init --tool=[TOOL] --bootstrap
-```
+**Step 1 - Tool Selection:** Ask which tool(s) the user is using. Multiple selections allowed:
 
-Replace `[TOOL]` with `antigravity`, `cursor`, or `claude`.
+- [ ] Cursor
+- [ ] Antigravity
+- [ ] Claude Code
+- [ ] Other (specify)
 
-Afterward, the user can edit `{skill-root}/_config/core.yaml` and `{skill-root}/_config/bmm.yaml`, or you can run the **Configure Installation** questions and apply the answers to those files.
+**Step 2 - Scope Selection:** For EACH selected tool, ask:
 
----
+- [ ] Project-specific (skills in current project only)
+- [ ] Global (skills available in all projects)
 
-## Manual Workflow
+**Step 3 - Configuration:** Ask each setting, offer defaults:
 
-Use when the user wants a guided experience, needs **global** install, or when you must run Fetch & Convert and Install as separate steps.
+| Setting | Question | Default |
+|---------|----------|---------|
+| `user_name` | What should agents call you? | BMad |
+| `communication_language` | Language for AI chat? | English |
+| `document_output_language` | Language for documents? | English |
+| `output_folder` | Where to save output files? | `_bmad-output` |
+| `project_name` | What is your project called? | *(directory name)* |
+| `user_skill_level` | Your development experience? | `intermediate` |
+| `planning_artifacts` | Where to store planning docs? | `{output_folder}/planning-artifacts` |
+| `implementation_artifacts` | Where to store implementation docs? | `{output_folder}/implementation-artifacts` |
+| `project_knowledge` | Where to store project knowledge? | `docs` |
 
-### Step 1: Tool Selection
+If user says "use defaults", skip individual questions and use all defaults.
 
-Ask which tool(s) the user is using. Multiple selections are allowed:
+### Phase 2: Confirm
 
-- [ ] Claude Code
-- [ ] Cursor
-- [ ] Antigravity
-- [ ] Other (Specify)
+Summarize the plan showing:
 
-### Step 2: Installation Scope
+1. Each tool + scope + resolved `{skill-root}` path
+2. Configuration values to apply
+3. Exact commands to run
 
-Ask whether to install skills **globally** or **project-specific**:
+**Wait for explicit "yes" or confirmation before proceeding.**
 
-| Scope | Description | Destination |
-|-------|-------------|-------------|
-| **Global** | Skills available across all projects | Cursor: `~/.cursor/skills/`; Antigravity: `~/.gemini/antigravity/skills/`; Claude Code: `~/.claude/skills/` |
-| **Project-Specific** | Skills limited to current repo | Cursor: `.cursor/skills/`; Antigravity: `.agent/skills/`; Claude Code: `.claude/skills/` |
+### Phase 3: Execute (Unified Steps)
 
-**Note:** On **install**, use `--scope=project` (default) or `--scope=global` / `--global`. Project: `.{tool}/skills/` under cwd (run from project root). Global: `~/.cursor/skills` etc.; `--tool` required.
+**IMPORTANT:** Use these SAME steps for 1 tool or multiple tools. No branching.
 
-### Step 3: Fetch & Convert
+**Step A - Convert once:**
 
 ```bash
 npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills
 ```
 
-### Step 4: Install
+Wait for this to complete before proceeding.
+
+**Step B - Install to EACH tool:**
 
-**Project-specific** (default; run from project root):
+For each tool+scope the user selected, run:
 
 ```bash
-npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --tool=[TOOL] --force
+npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --tool=[TOOL] [--scope=global] --force
 ```
 
-**Global** (`--tool` required; works from any directory):
+Replace `[TOOL]` with: `cursor`, `antigravity`, or `claude`
+
+Include `--scope=global` only if user chose global scope for that tool.
+
+**Step C - Cleanup:**
 
 ```bash
-npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --tool=[TOOL] --force --scope=global
+rm -rf .temp
 ```
 
-(`--global` = `--scope=global`.)
+### Phase 4: Update Configuration
 
-### Step 5: Clean up
+For EACH `{skill-root}` (one per tool installed), update the config files with user's answers:
 
-```bash
-rm -rf .temp
+**Update `{skill-root}/_config/core.yaml`:**
+
+```yaml
+user_name: '[user_name value]'
+communication_language: [communication_language value]
+document_output_language: [document_output_language value]
+output_folder: "[output_folder value]"
 ```
 
----
+**Update `{skill-root}/_config/bmm.yaml`:**
 
-## Configure Installation
+```yaml
+project_name: '[project_name value]'
+user_skill_level: [user_skill_level value]
+planning_artifacts: "[planning_artifacts value]"
+implementation_artifacts: "[implementation_artifacts value]"
+project_knowledge: "[project_knowledge value]"
 
-Prompt the user for each configuration setting. Offer the defaults shown:
+# Inherited core values
+user_name: '[user_name value]'
+communication_language: [communication_language value]
+document_output_language: [document_output_language value]
+output_folder: "[output_folder value]"
+```
 
-### Core Configuration (`{skill-root}/_config/core.yaml`)
+### Phase 5: Verify
 
-| Setting | Question | Default |
-|---------|----------|---------|
-| `user_name` | What should agents call you? (Use your name or a team name) | BMad |
-| `communication_language` | What language should agents use when chatting with you? | English |
-| `document_output_language` | Preferred document output language? | English |
-| `output_folder` | Where should output files be saved? | `_bmad-output` |
+For each installed tool, confirm:
 
-### BMM Configuration (`{skill-root}/_config/bmm.yaml`)
+1. Skills directory exists with skill folders (e.g., `bmm-analyst/SKILL.md`)
+2. `{skill-root}/_config/core.yaml` exists with user's values
+3. `{skill-root}/_config/bmm.yaml` exists with user's values
 
-| Setting | Question | Default |
-|---------|----------|---------|
-| `project_name` | What is your project called? | *(directory name)* |
-| `user_skill_level` | What is your development experience level? | `intermediate` |
-| `planning_artifacts` | Where should planning artifacts be stored? (Brainstorming, Briefs, PRDs, UX Designs, Architecture, Epics) | `{output_folder}/planning-artifacts` |
-| `implementation_artifacts` | Where should implementation artifacts be stored? (Sprint status, stories, reviews, retrospectives, Quick Flow output) | `{output_folder}/implementation-artifacts` |
-| `project_knowledge` | Where should long-term project knowledge be stored? (docs, research, references) | `docs` |
+Report results to user.
+
+---
+
+## Skill Root Reference
+
+`{skill-root}` resolves to different paths based on tool and scope:
+
+| Tool | Project Scope | Global Scope |
+|------|---------------|--------------|
+| **Cursor** | `.cursor/skills/` | `~/.cursor/skills/` |
+| **Antigravity** | `.agent/skills/` | `~/.gemini/antigravity/skills/` |
+| **Claude Code** | `.claude/skills/` | `~/.claude/skills/` |
+
+**Important:** Config files MUST be inside `{skill-root}/_config/`, NOT at project root.
 
 ---
 
-## Verify
+## Quick Start (Unattended)
+
+Skip prompts and use defaults. Replace `[TOOL]` with `cursor`, `antigravity`, or `claude`.
 
-1. Skills installed at the correct destination
-2. Config files exist: `_config/core.yaml`, `_config/bmm.yaml`
-3. Paths under `_config` use the `{skill-root}` variable
+```bash
+npx @clfhhc/bmad-methods-skills --output-dir .temp/converted-skills && \
+npx @clfhhc/bmad-methods-skills install --from=.temp/converted-skills --tool=[TOOL] --force && \
+rm -rf .temp
+```
+
+*Omit `--tool` to auto-detect. Add `--scope=global` for global.*
+
+After installation, run **BS** to configure settings, or manually edit `{skill-root}/_config/core.yaml` and `{skill-root}/_config/bmm.yaml`.
+
+---
 
 ## Guidelines
 
-- **Guided Flow**: For `BS`, follow **When You Run BS (Guided Flow)** above.
-- **Confirmation**: Always summarize the plan and ask for confirmation before executing automated installation commands.
-- **Defaults**: Offer defaults—don’t force the user to answer every question if they accept the suggested values.
-- **Overwrite**: Ask before overwriting existing skills unless `--force` is used.
+- **Always confirm** before executing installation commands
+- **Offer defaults** - don't force user to answer every question
+- **No branching** - use the same convert+install steps for 1 or many tools
+- **Handle errors gracefully** - if a command fails, report it and continue if possible
+- **Verify installation** - always check that config files exist in the correct location

package/src/converters/agent-converter.js

@@ -1,5 +1,6 @@
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
+import { sanitizeSkillName } from '../utils/sanitizer.js';
 
 /**
  * Converts a BMAD agent.yaml file to Claude Skills SKILL.md format
@@ -43,7 +44,9 @@ export async function convertAgentToSkill(agentPath, options = {}) {
     const startupMessage = agentData.startup_message || '';
 
     // Extract and sanitize name
-    const name = sanitizeName(metadata.id || metadata.name || 'unknown-agent');
+    const name = sanitizeSkillName(
+      metadata.id || metadata.name || 'unknown-agent'
+    );
 
     // Build description from role and identity
     const role = persona.role || 'Agent';
@@ -75,6 +78,7 @@ export async function convertAgentToSkill(agentPath, options = {}) {
       allAgents: options.allAgents || [],
       allWorkflows: options.allWorkflows || [],
       currentModule: options.currentModule || null,
+      parsingPatterns: options.parsingPatterns || {},
     });
 
     return skillContent;
@@ -83,19 +87,6 @@ export async function convertAgentToSkill(agentPath, options = {}) {
   }
 }
 
-/**
- * Sanitizes a name for use in SKILL.md frontmatter
- * @param {string} name - Original name
- * @returns {string} Sanitized name
- */
-function sanitizeName(name) {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-}
-
 /**
  * Builds the complete SKILL.md content for an agent
  */
@@ -110,6 +101,7 @@ function buildAgentSkillContent({
   allAgents,
   allWorkflows,
   currentModule,
+  parsingPatterns = {},
 }) {
   const displayName = metadata.name || metadata.title || name;
   const role = persona.role || 'Agent';
@@ -121,11 +113,19 @@ function buildAgentSkillContent({
     principles = principlesRaw;
   } else if (typeof principlesRaw === 'string') {
     // Parse multiline string format: extract lines starting with "-"
+    const principleLineRegex =
+      parsingPatterns.principleLineRegex || '^-\\s*[\'"]?';
+    const principleTrailingQuoteRegex =
+      parsingPatterns.principleTrailingQuoteRegex || '[\'"]\\s*$';
     principles = principlesRaw
       .split('\n')
       .map((line) => line.trim())
       .filter((line) => line.length > 0 && line.startsWith('-'))
-      .map((line) => line.replace(/^-\s*['"]?/, '').replace(/['"]\s*$/, ''));
+      .map((line) =>
+        line
+          .replace(new RegExp(principleLineRegex), '')
+          .replace(new RegExp(principleTrailingQuoteRegex), '')
+      );
   }
   const communicationStyle = persona.communication_style || '';
 
@@ -189,7 +189,7 @@ ${menu
     const desc = item.description || 'No description';
     // Format command with better structure
     const commandCode = `\`${trigger}\``;
-    return `- **${commandCode}** or fuzzy match on \`${trigger.toLowerCase().replace(/\s+/g, '-')}\` - ${desc}`;
+    return `- **${commandCode}** or fuzzy match on \`${trigger.toLowerCase().replace(new RegExp(parsingPatterns.triggerSanitizationRegex || '\\s+', 'g'), '-')}\` - ${desc}`;
   })
   .join('\n')}`;
   }
@@ -210,24 +210,34 @@ ${menu
       const trigger = item.trigger || 'unknown';
       const desc = item.description || 'No description';
       // Extract workflow code from description if it references a workflow (e.g., [WS])
-      const workflowMatch = desc.match(/\[(\w+)\]/);
+      const workflowCodeRegex =
+        parsingPatterns.workflowCodeRegex || '\\[(\\w+)\\]';
+      const workflowMatch = desc.match(new RegExp(workflowCodeRegex));
       const workflowCode = workflowMatch ? workflowMatch[1] : null;
 
       // Extract just the short code (e.g., "WS" from "WS or fuzzy match on workflow-status")
-      const shortCode = trigger.split(/\s+/)[0];
+      const shortCode = trigger.split(
+        new RegExp(parsingPatterns.triggerSanitizationRegex || '\\s+')
+      )[0];
 
       // Try to find the workflow
       let workflow = null;
       if (workflowCode) {
+        const hyphenRegex = parsingPatterns.hyphenRegex || '-';
+        const underscoreRegex = parsingPatterns.underscoreRegex || '_';
         workflow = allWorkflows.find(
           (w) =>
-            w.name.toLowerCase().replace(/-/g, '') ===
-            workflowCode.toLowerCase().replace(/_/g, '')
+            w.name.toLowerCase().replace(new RegExp(hyphenRegex, 'g'), '') ===
+            workflowCode
+              .toLowerCase()
+              .replace(new RegExp(underscoreRegex, 'g'), '')
         );
       }
 
       // Build a concise example - just description and code, no redundancy
-      const cleanDesc = desc.replace(/\[(\w+)\]\s*/, '').trim();
+      const cleanDesc = desc
+        .replace(new RegExp(`${workflowCodeRegex}\\s*`), '')
+        .trim();
       content += `\n\n**${cleanDesc}**`;
 
       if (workflow) {
@@ -247,12 +257,21 @@ ${menu
   for (const item of menu) {
     const desc = item.description || '';
     // Look for workflow references in format [WS], [BP], etc.
-    const workflowCodes = desc.match(/\[(\w+)\]/g) || [];
+    const workflowCodeRegex =
+      parsingPatterns.workflowCodeRegex || '\\[(\\w+)\\]';
+    const workflowCodes = desc.match(new RegExp(workflowCodeRegex, 'g')) || [];
     for (const code of workflowCodes) {
-      const codeName = code.replace(/[[\]]/g, '').toLowerCase();
+      const bracketRemovalRegex =
+        parsingPatterns.bracketRemovalRegex || '[[\\]]';
+      const codeName = code
+        .replace(new RegExp(bracketRemovalRegex, 'g'), '')
+        .toLowerCase();
       // Try to match workflow names
       const matchingWorkflow = allWorkflows.find((w) => {
-        const wName = w.name.toLowerCase().replace(/-/g, '');
+        const hyphenRegex = parsingPatterns.hyphenRegex || '-';
+        const wName = w.name
+          .toLowerCase()
+          .replace(new RegExp(hyphenRegex, 'g'), '');
         return (
           wName.includes(codeName) || codeName.includes(wName.substring(0, 2))
         );

package/src/converters/workflow-converter.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import yaml from 'js-yaml';
+import { sanitizeSkillName } from '../utils/sanitizer.js';
 
 /**
  * Converts a BMAD workflow to Claude Skills SKILL.md format
@@ -19,7 +20,7 @@ export async function convertWorkflowToSkill(
   _instructionsType = null,
   options = {}
 ) {
-  const { isMarkdown } = {
+  const { isMarkdown, parsingPatterns = {} } = {
     isMarkdown: false,
     ...options,
   };
@@ -46,8 +47,11 @@ export async function convertWorkflowToSkill(
 
       // Parse frontmatter and content
       // More flexible regex: allows optional newlines and handles various formats
+      const frontmatterRegex =
+        parsingPatterns.frontmatterRegex ||
+        '^---\\s*\\n([\\s\\S]*?)\\n---\\s*\\n([\\s\\S]*)$';
       const frontmatterMatch = workflowContent.match(
-        /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/
+        new RegExp(frontmatterRegex)
       );
 
       if (frontmatterMatch) {
@@ -64,17 +68,19 @@ export async function convertWorkflowToSkill(
         // The markdown content IS the instructions
         // Normalize headings to ensure hierarchy fits under "## Instructions"
         // Downgrade all headings: # -> ###, ## -> ####
-        instructionsContent = parseInstructions(markdownContent).replace(
-          /^(#+)/gm,
-          '##$1'
-        );
+        const headingRegex = parsingPatterns.markdownHeadingRegex || '^(#+)';
+        instructionsContent = parseInstructions(
+          markdownContent,
+          parsingPatterns
+        ).replace(new RegExp(headingRegex, 'gm'), '##$1');
       } else {
         // No frontmatter, treat entire file as instructions
         // Try to extract basic metadata from filename or use defaults
-        instructionsContent = parseInstructions(workflowContent).replace(
-          /^(#+)/gm,
-          '##$1'
-        );
+        const headingRegex = parsingPatterns.markdownHeadingRegex || '^(#+)';
+        instructionsContent = parseInstructions(
+          workflowContent,
+          parsingPatterns
+        ).replace(new RegExp(headingRegex, 'gm'), '##$1');
       }
     } else if (workflowPath.endsWith('.xml')) {
       // workflow.xml format: pure XML file (like advanced-elicitation)
@@ -87,8 +93,12 @@ export async function convertWorkflowToSkill(
 
       // Extract metadata from XML task attributes
       // Example: <task id="..." name="Advanced Elicitation" standalone="true" ...>
-      const nameMatch = xmlContent.match(/name="([^"]+)"/);
-      const standaloneMatch = xmlContent.match(/standalone="([^"]+)"/);
+      const xmlNameRegex =
+        parsingPatterns.xmlNameAttributeRegex || 'name="([^"]+)"';
+      const xmlStandaloneRegex =
+        parsingPatterns.xmlStandaloneAttributeRegex || 'standalone="([^"]+)"';
+      const nameMatch = xmlContent.match(new RegExp(xmlNameRegex));
+      const standaloneMatch = xmlContent.match(new RegExp(xmlStandaloneRegex));
 
       workflow = {
         name: nameMatch ? nameMatch[1] : path.basename(workflowDir),
@@ -97,7 +107,7 @@ export async function convertWorkflowToSkill(
       };
 
       // Parse the XML content as instructions
-      instructionsContent = parseXmlInstructions(xmlContent);
+      instructionsContent = parseXmlInstructions(xmlContent, parsingPatterns);
     } else {
       // workflow.yaml format: separate YAML file + instructions file
       const workflowContent = await fs.readFile(workflowPath, 'utf-8');
@@ -129,7 +139,7 @@ export async function convertWorkflowToSkill(
     }
 
     // Extract workflow metadata
-    const name = sanitizeName(workflow.name || path.basename(workflowDir));
+    const name = sanitizeSkillName(workflow.name || path.basename(workflowDir));
     const description = workflow.description || 'Workflow';
     const standalone = workflow.standalone !== false; // Default to true
     const inputs = workflow.inputs || {};
@@ -275,34 +285,25 @@ export async function convertWorkflowToSkill(
   }
 }
 
-/**
- * Sanitizes a name for use in SKILL.md frontmatter
- * @param {string} name - Original name
- * @returns {string} Sanitized name
- */
-function sanitizeName(name) {
-  return name
-    .toLowerCase()
-    .replace(/[^a-z0-9-]/g, '-')
-    .replace(/-+/g, '-')
-    .replace(/^-|-$/g, '');
-}
-
 /**
  * Parses XML instructions.xml to markdown
  * @param {string} xmlContent - Raw XML instructions content
  * @returns {string} Parsed markdown
  */
-function parseXmlInstructions(xmlContent) {
+function parseXmlInstructions(xmlContent, patterns = {}) {
   let parsed = xmlContent;
 
   // Extract task-level metadata from <task> attributes
-  const taskMatch = parsed.match(/<task\s+([^>]+)>/i);
+  const taskRegex = patterns.taskTagRegex || '<task\\s+([^>]+)>';
+  const taskMatch = parsed.match(new RegExp(taskRegex, 'i'));
   let taskHeader = '';
   if (taskMatch) {
     const attrs = taskMatch[1];
-    const nameMatch = attrs.match(/name="([^"]+)"/);
-    const standaloneMatch = attrs.match(/standalone="([^"]+)"/);
+    const xmlNameRegex = patterns.xmlNameAttributeRegex || 'name="([^"]+)"';
+    const xmlStandaloneRegex =
+      patterns.xmlStandaloneAttributeRegex || 'standalone="([^"]+)"';
+    const nameMatch = attrs.match(new RegExp(xmlNameRegex));
+    const standaloneMatch = attrs.match(new RegExp(xmlStandaloneRegex));
     if (nameMatch) {
       taskHeader = `# ${nameMatch[1]}\n\n`;
       if (standaloneMatch && standaloneMatch[1] === 'true') {
@@ -312,14 +313,18 @@ function parseXmlInstructions(xmlContent) {
   }
 
   // Remove task wrapper
-  parsed = parsed.replace(/<task\s+[^>]+>/gi, '');
-  parsed = parsed.replace(/<\/task>/gi, '');
+  parsed = parsed.replace(new RegExp(taskRegex, 'gi'), '');
+  const taskCloseRegex = patterns.taskCloseTagRegex || '<\\/task>';
+  parsed = parsed.replace(new RegExp(taskCloseRegex, 'gi'), '');
 
   // Convert <llm critical="true">...</llm> to a Critical section
+  const llmCriticalRegex =
+    patterns.llmCriticalTagRegex ||
+    '<llm\\s+critical="true">([\\s\\S]*?)<\\/llm>';
   parsed = parsed.replace(
-    /<llm\s+critical="true">([\s\S]*?)<\/llm>/gi,
+    new RegExp(llmCriticalRegex, 'gi'),
     (_match, content) => {
-      const items = extractInstructionItems(content);
+      const items = extractInstructionItems(content, patterns);
       if (items.length > 0) {
         return `\n\n## Critical Instructions\n\n${items.map((i) => `> ⚠️ ${i}`).join('\n')}\n`;
       }
@@ -328,43 +333,59 @@ function parseXmlInstructions(xmlContent) {
   );
 
   // Remove any remaining <llm> tags
-  parsed = parsed.replace(/<llm[^>]*>/gi, '');
-  parsed = parsed.replace(/<\/llm>/gi, '');
+  const llmOpenRegex = patterns.llmOpenTagRegex || '<llm[^>]*>';
+  const llmCloseRegex = patterns.llmCloseTagRegex || '<\\/llm>';
+  parsed = parsed.replace(new RegExp(llmOpenRegex, 'gi'), '');
+  parsed = parsed.replace(new RegExp(llmCloseRegex, 'gi'), '');
 
   // Convert <integration description="...">...</integration>
+  const integrationRegex =
+    patterns.integrationTagRegex ||
+    '<integration\\s+description="([^"]+)">([\\s\\S]*?)<\\/integration>';
   parsed = parsed.replace(
-    /<integration\s+description="([^"]+)">([\s\S]*?)<\/integration>/gi,
+    new RegExp(integrationRegex, 'gi'),
     (_match, desc, content) => {
-      const items = extractInstructionItems(content);
+      const items = extractInstructionItems(content, patterns);
       return `\n\n## ${desc}\n\n${items.map((i) => `- ${i}`).join('\n')}\n`;
     }
   );
 
   // Convert <flow>...</flow> wrapper
-  parsed = parsed.replace(/<flow>/gi, '\n\n## Workflow Steps\n');
-  parsed = parsed.replace(/<\/flow>/gi, '');
+  const flowOpenRegex = patterns.flowOpenTagRegex || '<flow>';
+  const flowCloseRegex = patterns.flowCloseTagRegex || '<\\/flow>';
+  parsed = parsed.replace(
+    new RegExp(flowOpenRegex, 'gi'),
+    '\n\n## Workflow Steps\n'
+  );
+  parsed = parsed.replace(new RegExp(flowCloseRegex, 'gi'), '');
 
   // Convert <step n="1" title="...">
+  const stepRegex =
+    patterns.stepTagRegex ||
+    '<step\\s+n="(\\d+)"(?:\\s+title="([^"]+)")?(?:\\s+goal="([^"]+)")?[^>]*>';
+  const stepCloseRegex = patterns.stepCloseTagRegex || '<\\/step>';
   parsed = parsed.replace(
-    /<step\s+n="(\d+)"(?:\s+title="([^"]+)")?(?:\s+goal="([^"]+)")?[^>]*>/gi,
+    new RegExp(stepRegex, 'gi'),
     (_match, num, title, goal) => {
       const stepTitle = title || goal || `Step ${num}`;
       return `\n\n### Step ${num}: ${stepTitle}\n`;
     }
   );
-  parsed = parsed.replace(/<\/step>/gi, '');
+  parsed = parsed.replace(new RegExp(stepCloseRegex, 'gi'), '');
 
   // Convert <case n="...">...</case> for response handling
+  const caseRegex =
+    patterns.caseTagRegex || '<case\\s+n="([^"]+)">([\\s\\S]*?)<\\/case>';
   parsed = parsed.replace(
-    /<case\s+n="([^"]+)">([\s\S]*?)<\/case>/gi,
+    new RegExp(caseRegex, 'gi'),
     (_match, caseId, content) => {
-      const items = extractInstructionItems(content);
+      const items = extractInstructionItems(content, patterns);
       return `\n\n**Case "${caseId}":**\n${items.map((i) => `  - ${i}`).join('\n')}\n`;
     }
   );
 
   // Convert named sections like <csv-structure>, <context-analysis>, <smart-selection>, <format>, <response-handling>
-  const namedSections = [
+  const namedSections = patterns.namedSections || [
     'csv-structure',
     'context-analysis',
     'smart-selection',
@@ -375,8 +396,13 @@ function parseXmlInstructions(xmlContent) {
     'halt-conditions',
   ];
   for (const section of namedSections) {
+    const template =
+      patterns.sectionRegexTemplate ||
+      '<{{section}}[^>]*>([\\s\\S]*?)<\\/{{section}}>';
+    const placeholder =
+      patterns.sectionTemplatePlaceholderRegex || '{{section}}';
     const sectionRegex = new RegExp(
-      `<${section}[^>]*>([\\s\\S]*?)<\\/${section}>`,
+      template.replace(new RegExp(placeholder, 'g'), section),
       'gi'
     );
     parsed = parsed.replace(sectionRegex, (_match, content) => {
@@ -386,7 +412,7 @@ function parseXmlInstructions(xmlContent) {
         .join(' ');
 
       // Check if content has <i> items or is plain text
-      const items = extractInstructionItems(content);
+      const items = extractInstructionItems(content, patterns);
       if (items.length > 0) {
         return `\n\n**${sectionTitle}:**\n${items.map((i) => `- ${i}`).join('\n')}\n`;
       }
@@ -396,79 +422,108 @@ function parseXmlInstructions(xmlContent) {
   }
 
   // Convert any remaining <desc>...</desc>
-  parsed = parsed.replace(/<desc>([^<]+)<\/desc>/gi, (_match, content) => {
+  const descRegex = patterns.descTagRegex || '<desc>([^<]+)<\\/desc>';
+  parsed = parsed.replace(new RegExp(descRegex, 'gi'), (_match, content) => {
     return `\n*${content.trim()}*\n`;
   });
 
   // Convert standalone <i>...</i> items (instruction items) to bullet points
   // Use [\s\S]*? to match across newlines and normalize whitespace
-  parsed = parsed.replace(/<i>([\s\S]*?)<\/i>/gi, (_match, content) => {
-    const normalized = content.replace(/\s+/g, ' ').trim();
-    return `\n- ${normalized}`;
-  });
+  const instructionItemRegex =
+    patterns.instructionItemTagRegex || '<i>([\\s\\S]*?)<\\/i>';
+  const whitespaceRegex = patterns.whitespaceRegex || '\\s+';
+  parsed = parsed.replace(
+    new RegExp(instructionItemRegex, 'gi'),
+    (_match, content) => {
+      const normalized = content
+        .replace(new RegExp(whitespaceRegex, 'g'), ' ')
+        .trim();
+      return `\n- ${normalized}`;
+    }
+  );
 
   // Convert <action>...</action> to - **Action:** ...
-  parsed = parsed.replace(/<action>([^<]+)<\/action>/gi, (_match, content) => {
+  const actionRegex = patterns.actionTagRegex || '<action>([^<]+)<\\/action>';
+  parsed = parsed.replace(new RegExp(actionRegex, 'gi'), (_match, content) => {
     return `\n- **Action:** ${content.trim()}`;
   });
 
   // Convert <ask>...</ask> to - **Ask:** ...
-  parsed = parsed.replace(/<ask>([^<]+)<\/ask>/gi, (_match, content) => {
+  const askRegex = patterns.askTagRegex || '<ask>([^<]+)<\\/ask>';
+  parsed = parsed.replace(new RegExp(askRegex, 'gi'), (_match, content) => {
     return `\n- **Ask:** ${content.trim()}`;
   });
 
   // Convert <critical>...</critical>
+  const criticalRegex =
+    patterns.criticalTagRegex || '<critical>([^<]+)<\\/critical>';
   parsed = parsed.replace(
-    /<critical>([^<]+)<\/critical>/gi,
+    new RegExp(criticalRegex, 'gi'),
     (_match, content) => {
       return `\n> **Critical:** ${content.trim()}`;
     }
   );
 
   // Convert <output>...</output>
-  parsed = parsed.replace(/<output>([^<]+)<\/output>/gi, (_match, content) => {
+  const outputRegex = patterns.outputTagRegex || '<output>([^<]+)<\\/output>';
+  parsed = parsed.replace(new RegExp(outputRegex, 'gi'), (_match, content) => {
     return `\n**Output:** ${content.trim()}`;
   });
 
   // Convert <check if="...">...</check>
+  const checkIfRegex =
+    patterns.checkIfTagRegex || '<check\\s+if="([^"]+)">([\\s\\S]*?)<\\/check>';
+  const checkCloseRegex = patterns.checkCloseTagRegex || '<\\/check>';
   parsed = parsed.replace(
-    /<check\s+if="([^"]+)">([\s\S]*?)<\/check>/gi,
+    new RegExp(checkIfRegex, 'gi'),
     (_match, condition, content) => {
-      const items = extractInstructionItems(content);
+      const items = extractInstructionItems(content, patterns);
       if (items.length > 0) {
         return `\n\n**Check if:** ${condition}\n${items.map((i) => `- ${i}`).join('\n')}\n`;
       }
       return `\n\n**Check if:** ${condition}\n`;
     }
   );
-  parsed = parsed.replace(/<\/check>/gi, '');
+  parsed = parsed.replace(new RegExp(checkCloseRegex, 'gi'), '');
 
   // Convert <goto anchor="..."/>
+  const gotoAnchorRegex =
+    patterns.gotoAnchorTagRegex || '<goto\\s+anchor="([^"]+)"\\s*\\/>';
   parsed = parsed.replace(
-    /<goto\s+anchor="([^"]+)"\s*\/>/gi,
+    new RegExp(gotoAnchorRegex, 'gi'),
     (_match, anchor) => `\n→ Go to: **${anchor}**`
   );
 
   // Convert <invoke-workflow>...</invoke-workflow>
+  const invokeWorkflowRegex =
+    patterns.invokeWorkflowTagRegex ||
+    '<invoke-workflow>([^<]+)<\\/invoke-workflow>';
   parsed = parsed.replace(
-    /<invoke-workflow>([^<]+)<\/invoke-workflow>/gi,
+    new RegExp(invokeWorkflowRegex, 'gi'),
     (_match, content) => `\n- **Invoke Workflow:** ${content.trim()}`
   );
 
   // Convert <template-output>...</template-output>
+  const templateOutputRegex =
+    patterns.templateOutputTagRegex ||
+    '<template-output>([^<]+)<\\/template-output>';
   parsed = parsed.replace(
-    /<template-output>([^<]+)<\/template-output>/gi,
+    new RegExp(templateOutputRegex, 'gi'),
     (_match, content) => `\n**Template Output:** ${content.trim()}`
   );
 
   // Clean up any remaining XML tags
-  parsed = parsed.replace(/<[^>]+>/g, '');
+  const anyTagRegex = patterns.anyTagRegex || '<[^>]+>';
+  parsed = parsed.replace(new RegExp(anyTagRegex, 'g'), '');
 
   // Add task header at the beginning
   parsed = taskHeader + parsed;
 
   // Clean up whitespace
-  parsed = parsed.replace(/\n{3,}/g, '\n\n').trim();
+  const multipleNewlinesRegex = patterns.multipleNewlinesRegex || '\\n{3,}';
+  parsed = parsed
+    .replace(new RegExp(multipleNewlinesRegex, 'g'), '\n\n')
+    .trim();
 
   return parsed;
 }
@@ -478,20 +533,25 @@ function parseXmlInstructions(xmlContent) {
  * Handles <i>...</i> and <desc>...</desc> tags
  * Normalizes whitespace to single spaces
  */
-function extractInstructionItems(content) {
+function extractInstructionItems(content, patterns = {}) {
   const items = [];
 
   // Helper to normalize whitespace (replace newlines and multiple spaces with single space)
-  const normalize = (text) => text.replace(/\s+/g, ' ').trim();
+  const whitespaceRegex = patterns.whitespaceRegex || '\\s+';
+  const normalize = (text) =>
+    text.replace(new RegExp(whitespaceRegex, 'g'), ' ').trim();
 
   // Extract <desc> first
-  const descMatches = content.matchAll(/<desc>([\s\S]*?)<\/desc>/gi);
+  const descRegex = patterns.descTagRegex || '<desc>([^<]+)<\\/desc>';
+  const descMatches = content.matchAll(new RegExp(descRegex, 'gi'));
   for (const match of descMatches) {
     items.push(normalize(match[1]));
   }
 
   // Extract <i> items (use [\s\S] to match across newlines)
-  const iMatches = content.matchAll(/<i>([\s\S]*?)<\/i>/gi);
+  const instructionItemRegex =
+    patterns.instructionItemTagRegex || '<i>([\\s\\S]*?)<\\/i>';
+  const iMatches = content.matchAll(new RegExp(instructionItemRegex, 'gi'));
   for (const match of iMatches) {
     items.push(normalize(match[1]));
   }
@@ -504,46 +564,57 @@ function extractInstructionItems(content) {
  * @param {string} instructions - Raw instructions content
  * @returns {string} Parsed markdown
  */
-function parseInstructions(instructions) {
+function parseInstructions(instructions, patterns = {}) {
   let parsed = instructions;
 
   // Convert <step n="1" goal="..."> to ## Step 1: ...
-  parsed = parsed.replace(
-    /<step\s+n="(\d+)"(?:\s+goal="([^"]+)")?>/gi,
-    (_match, num, goal) => {
-      return goal ? `## Step ${num}: ${goal}` : `## Step ${num}:`;
-    }
-  );
+  const stepRegex =
+    patterns.markdownStepTagRegex ||
+    '<step\\s+n="(\\d+)"(?:\\s+goal="([^"]+)")?>';
+  parsed = parsed.replace(new RegExp(stepRegex, 'gi'), (_match, num, goal) => {
+    return goal ? `## Step ${num}: ${goal}` : `## Step ${num}:`;
+  });
 
   // Convert </step> to empty (just close the section)
-  parsed = parsed.replace(/<\/step>/gi, '');
+  const stepCloseRegex = patterns.stepCloseTagRegex || '<\\/step>';
+  parsed = parsed.replace(new RegExp(stepCloseRegex, 'gi'), '');
 
   // Convert <ask>...</ask> to **Ask:** ...
-  parsed = parsed.replace(/<ask>(.*?)<\/ask>/gis, (_match, content) => {
+  const askRegex = patterns.markdownAskTagRegex || '<ask>(.*?)</ask>';
+  parsed = parsed.replace(new RegExp(askRegex, 'gis'), (_match, content) => {
     return `**Ask:** ${content.trim()}`;
   });
 
   // Convert <action>...</action> to **Action:** ...
-  parsed = parsed.replace(/<action>(.*?)<\/action>/gis, (_match, content) => {
+  const actionRegex =
+    patterns.markdownActionTagRegex || '<action>(.*?)</action>';
+  parsed = parsed.replace(new RegExp(actionRegex, 'gis'), (_match, content) => {
     return `**Action:** ${content.trim()}`;
   });
 
   // Convert <check>...</check> to **Check:** ...
-  parsed = parsed.replace(/<check>(.*?)<\/check>/gis, (_match, content) => {
+  const checkRegex = patterns.markdownCheckTagRegex || '<check>(.*?)</check>';
+  parsed = parsed.replace(new RegExp(checkRegex, 'gis'), (_match, content) => {
     return `**Check:** ${content.trim()}`;
   });
 
   // Convert <invoke-workflow>...</invoke-workflow> to **Invoke Workflow:** ...
+  const invokeWorkflowRegex =
+    patterns.markdownInvokeWorkflowTagRegex ||
+    '<invoke-workflow>(.*?)</invoke-workflow>';
   parsed = parsed.replace(
-    /<invoke-workflow>(.*?)<\/invoke-workflow>/gis,
+    new RegExp(invokeWorkflowRegex, 'gis'),
     (_match, content) => {
       return `**Invoke Workflow:** ${content.trim()}`;
     }
   );
 
   // Convert <template-output>...</template-output> to **Template Output:** ...
+  const templateOutputRegex =
+    patterns.markdownTemplateOutputTagRegex ||
+    '<template-output>(.*?)</template-output>';
   parsed = parsed.replace(
-    /<template-output>(.*?)<\/template-output>/gis,
+    new RegExp(templateOutputRegex, 'gis'),
     (_match, content) => {
       return `**Template Output:** ${content.trim()}`;
     }

package/src/utils/file-finder.js

@@ -17,6 +17,7 @@ export async function findAgentsAndWorkflows(
   workflowPaths,
   options = {}
 ) {
+  const parsingPatterns = options.workflowParsingPatterns || {};
   if (!bmadRoot || !(await fs.pathExists(bmadRoot))) {
     throw new Error(`BMAD root directory does not exist: ${bmadRoot}`);
   }
@@ -46,7 +47,11 @@ export async function findAgentsAndWorkflows(
           }
 
           const relativePath = path.relative(bmadRoot, filePath);
-          const module = extractModule(relativePath, moduleExtractionPatterns);
+          const module = extractModule(
+            relativePath,
+            moduleExtractionPatterns,
+            options.fallbackModuleExtractionPatterns
+          );
           const name = path.basename(filePath, '.agent.yaml');
 
           if (!name || name.trim() === '') {
@@ -125,7 +130,8 @@ export async function findAgentsAndWorkflows(
             const relativePath = path.relative(bmadRoot, absolutePath);
             const module = extractModule(
               relativePath,
-              moduleExtractionPatterns
+              moduleExtractionPatterns,
+              options.fallbackModuleExtractionPatterns
             );
 
             const isMarkdown = absolutePath.endsWith('.md');
@@ -136,7 +142,10 @@ export async function findAgentsAndWorkflows(
             // Extract name from file content
             const content = await fs.readFile(absolutePath, 'utf-8');
             if (isMarkdown) {
-              const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+              const frontmatterSimpleRegex =
+                parsingPatterns.frontmatterSimpleRegex ||
+                '^---\\s*\\n([\\s\\S]*?)\\n---';
+              const match = content.match(new RegExp(frontmatterSimpleRegex));
               if (match) {
                 try {
                   const frontmatter = yaml.load(match[1]);
@@ -146,7 +155,9 @@ export async function findAgentsAndWorkflows(
                 }
               }
             } else if (isXml) {
-              const match = content.match(/name="([^"]+)"/);
+              const xmlNameRegex =
+                parsingPatterns.xmlNameRegex || 'name="([^"]+)"';
+              const match = content.match(new RegExp(xmlNameRegex));
               if (match) name = match[1];
             } else {
               try {
@@ -247,24 +258,23 @@ export async function findAgentsAndWorkflows(
   return { agents, workflows };
 }
 
-function extractModule(relativePath, moduleExtractionPatterns) {
-  if (
+function extractModule(
+  relativePath,
+  moduleExtractionPatterns,
+  fallbackPatterns
+) {
+  const patterns =
     Array.isArray(moduleExtractionPatterns) &&
     moduleExtractionPatterns.length > 0
-  ) {
-    for (const { pattern, group } of moduleExtractionPatterns) {
+      ? moduleExtractionPatterns
+      : fallbackPatterns;
+
+  if (Array.isArray(patterns) && patterns.length > 0) {
+    for (const { pattern, group } of patterns) {
       const m = relativePath.match(new RegExp(pattern));
-      if (m && m[group] != null) return m[group];
+      if (m && m[group] != null) return m[group].toLowerCase();
     }
-    return null;
   }
 
-  // Fallback when moduleExtractionPatterns not provided (backward compatibility)
-  const modulesMatch = relativePath.match(/^src\/modules\/([^/]+)\//);
-  if (modulesMatch) return modulesMatch[1];
-
-  const srcMatch = relativePath.match(/^src\/([^/]+)\//);
-  if (srcMatch) return srcMatch[1];
-
   return null;
 }

package/src/utils/path-rewriter.js

@@ -1,3 +1,5 @@
+import { sanitizeSkillName } from './sanitizer.js';
+
 /**
  * Rewrites BMAD installation paths to relative skill paths
  * Converts {project-root}/_bmad/... references to relative skill paths
@@ -22,6 +24,7 @@ export function rewriteBmadPaths(
   const opts = skillMapOptions || {};
   const sourcePrefix = opts.sourcePrefix;
   const dirLookahead = opts.dirLookahead;
+  const fileLookahead = opts.fileLookahead;
   const replacementPrefix = opts.replacementPrefix;
   const outputStructure = opts.outputStructure ?? 'flat';
 
@@ -50,20 +53,32 @@ export function rewriteBmadPaths(
 
     // 1. Rewrite Workflow Files
     for (const [srcPath, { module, name }] of skillMap.entries()) {
+      const sanitizedName = sanitizeSkillName(name);
+      const sanitizedModule = sanitizeSkillName(module);
+
       // Create directory mapping while we're here
       // srcPath is e.g. "bmm/workflows/testarch/ci/workflow.yaml"
       const srcDir = srcPath.substring(0, srcPath.lastIndexOf('/'));
-      dirMap.set(srcDir, { module, name });
+      dirMap.set(srcDir, { module: sanitizedModule, name: sanitizedName });
 
       // Replace file reference
       // Pattern: {project-root}/_bmad/{srcPath}
       // srcPath is now normalized by convert.js
-      const escapedPath = srcPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-      const regex = new RegExp(`${sourcePrefix}${escapedPath}`, 'g');
+      const escapedPathRegex =
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: the curly braces are in regex
+        opts.escapedPathRegex || '[.*+?^${}()|[\\]\\\\]';
+      const escapedPath = srcPath.replace(
+        new RegExp(escapedPathRegex, 'g'),
+        '\\$&'
+      );
+      const regex = new RegExp(
+        `${sourcePrefix}${escapedPath}${fileLookahead || ''}`,
+        'g'
+      );
       const fileReplacement =
         outputStructure === 'flat'
-          ? `${replacementPrefix}/${module}-${name}/SKILL.md`
-          : `${replacementPrefix}/${module}/${name}/SKILL.md`;
+          ? `${replacementPrefix}/${sanitizedModule}-${sanitizedName}/SKILL.md`
+          : `${replacementPrefix}/${sanitizedModule}/${sanitizedName}/SKILL.md`;
       result = result.replace(regex, fileReplacement);
     }
 
@@ -74,16 +89,23 @@ export function rewriteBmadPaths(
     );
 
     for (const srcDir of sortedDirs) {
-      const { module, name } = dirMap.get(srcDir);
-      const escapedDir = srcDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const { module: sanitizedModule, name: sanitizedName } =
+        dirMap.get(srcDir);
+      const escapedPathRegex =
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: the curly braces are in regex
+        opts.escapedPathRegex || '[.*+?^${}()|[\\]\\\\]';
+      const escapedDir = srcDir.replace(
+        new RegExp(escapedPathRegex, 'g'),
+        '\\$&'
+      );
       const regex = new RegExp(
         `${sourcePrefix}${escapedDir}${dirLookahead}`,
         'g'
       );
       const dirReplacement =
         outputStructure === 'flat'
-          ? `${replacementPrefix}/${module}-${name}`
-          : `${replacementPrefix}/${module}/${name}`;
+          ? `${replacementPrefix}/${sanitizedModule}-${sanitizedName}`
+          : `${replacementPrefix}/${sanitizedModule}/${sanitizedName}`;
       result = result.replace(regex, dirReplacement);
     }
   }

package/src/utils/sanitizer.js

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import fs from 'fs-extra';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const configPath = path.join(__dirname, '../../config.json');
+export const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+
+/**
+ * Sanitizes a skill name for use in file paths and URLs.
+ * Ensures lowercase, removes invalid characters, and collapses hyphens.
+ * @param {string} name - The original skill name
+ * @returns {string} The sanitized, lowercase name
+ */
+export function sanitizeSkillName(name) {
+  if (!name) return '';
+
+  const patterns = config.sanitization || {};
+  const invalidCharsRegex = patterns.invalidCharsRegex || '[^a-z0-9-]';
+  const multipleHyphensRegex = patterns.multipleHyphensRegex || '-+';
+  const leadingTrailingHyphensRegex =
+    patterns.leadingTrailingHyphensRegex || '^-|-$';
+
+  return name
+    .toLowerCase()
+    .replace(new RegExp(invalidCharsRegex, 'g'), '-')
+    .replace(new RegExp(multipleHyphensRegex, 'g'), '-')
+    .replace(new RegExp(leadingTrailingHyphensRegex, 'g'), ''); // Remove leading/trailing hyphens
+}

package/src/utils/skill-writer.js

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import fs from 'fs-extra';
 import { rewriteBmadPaths, shouldRewritePaths } from './path-rewriter.js';
+import { config, sanitizeSkillName } from './sanitizer.js';
 
 /**
  * Writes a SKILL.md file and related resources to the output directory
@@ -31,11 +32,18 @@ export async function writeSkill(
     throw new Error('skillContent must be a non-empty string');
   }
 
-  // Sanitize skillName to prevent directory traversal
-  const sanitizedName = skillName
-    .replace(/[^a-z0-9-]/gi, '-')
-    .replace(/-+/g, '-');
-  if (sanitizedName !== skillName) {
+  // Sanitize skillName to prevent directory traversal and ensure consistent casing
+  const sanitizedName = sanitizeSkillName(skillName);
+  const lowercaseName = skillName.toLowerCase();
+
+  const patterns = config.sanitization || {};
+  const trailingHyphensRegex = patterns.trailingHyphensRegex || '-+$';
+
+  if (
+    sanitizedName !== lowercaseName &&
+    sanitizedName !==
+      lowercaseName.replace(new RegExp(trailingHyphensRegex), '')
+  ) {
     console.warn(
       `Warning: Skill name sanitized from "${skillName}" to "${sanitizedName}"`
     );