ma-agents 3.4.7 → 3.4.8

package/.opencode/skills/bmad-help/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: bmad-help
+description: 'Analyzes current state and user query to answer BMad questions or recommend the next skill(s) to use. Use when user asks for help, bmad help, what to do next, or what to start with in BMad.'
+---
+
+# BMad Help
+
+## Purpose
+
+Help the user understand where they are in their BMad workflow and what to do next. Answer BMad questions when asked.
+
+## Desired Outcomes
+
+When this skill completes, the user should:
+
+1. **Know where they are** — which module and phase they're in, what's already been completed
+2. **Know what to do next** — the next recommended and/or required step, with clear reasoning
+3. **Know how to invoke it** — skill name, menu code, action context, and any args that shortcut the conversation
+4. **Get offered a quick start** — when a single skill is the clear next step, offer to run it for the user right now rather than just listing it
+5. **Feel oriented, not overwhelmed** — surface only what's relevant to their current position; don't dump the entire catalog
+
+## Data Sources
+
+- **Catalog**: `{project-root}/_bmad/_config/bmad-help.csv` — assembled manifest of all installed module skills
+- **Config**: `config.yaml` and `user-config.yaml` files in `{project-root}/_bmad/` and its subfolders — resolve `output-location` variables, provide `communication_language` and `project_knowledge`
+- **Artifacts**: Files matching `outputs` patterns at resolved `output-location` paths reveal which steps are possibly completed; their content may also provide grounding context for recommendations
+- **Project knowledge**: If `project_knowledge` resolves to an existing path, read it for grounding context. Never fabricate project-specific details.
+
+## CSV Interpretation
+
+The catalog uses this format:
+
+```
+module,skill,display-name,menu-code,description,action,args,phase,after,before,required,output-location,outputs
+```
+
+**Phases** determine the high-level flow:
+- `anytime` — available regardless of workflow state
+- Numbered phases (`1-analysis`, `2-planning`, etc.) flow in order; naming varies by module
+
+**Dependencies** determine ordering within and across phases:
+- `after` — skills that should ideally complete before this one
+- `before` — skills that should run after this one
+- Format: `skill-name` for single-action skills, `skill-name:action` for multi-action skills
+
+**Required gates**:
+- `required=true` items must complete before the user can meaningfully proceed to later phases
+- A phase with no required items is entirely optional — recommend it but be clear about what's actually required next
+
+**Completion detection**:
+- Search resolved output paths for `outputs` patterns
+- Fuzzy-match found files to catalog rows
+- User may also state completion explicitly, or it may be evident from the current conversation
+
+**Descriptions carry routing context** — some contain cycle info and alternate paths (e.g., "back to DS if fixes needed"). Read them as navigation hints, not just display text.
+
+## Response Format
+
+For each recommended item, present:
+- `[menu-code]` **Display name** — e.g., "[CP] Create PRD"
+- Skill name in backticks — e.g., `bmad-create-prd`
+- For multi-action skills: action invocation context — e.g., "tech-writer lets create a mermaid diagram!"
+- Description if present in CSV; otherwise your existing knowledge of the skill suffices
+- Args if available
+
+**Ordering**: Show optional items first, then the next required item. Make it clear which is which.
+
+## Constraints
+
+- Present all output in `{communication_language}`
+- Recommend running each skill in a **fresh context window**
+- Match the user's tone — conversational when they're casual, structured when they want specifics
+- If the active module is ambiguous, ask rather than guess

package/.opencode/skills/bmad-index-docs/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: bmad-index-docs
+description: 'Generates or updates an index.md to reference all docs in the folder. Use if user requests to create or update an index of all files in a specific folder'
+---
+
+# Index Docs
+
+**Goal:** Generate or update an index.md to reference all docs in a target folder.
+
+
+## EXECUTION
+
+### Step 1: Scan Directory
+
+- List all files and subdirectories in the target location
+
+### Step 2: Group Content
+
+- Organize files by type, purpose, or subdirectory
+
+### Step 3: Generate Descriptions
+
+- Read each file to understand its actual purpose and create brief (3-10 word) descriptions based on the content, not just the filename
+
+### Step 4: Create/Update Index
+
+- Write or update index.md with organized file listings
+
+
+## OUTPUT FORMAT
+
+```markdown
+# Directory Index
+
+## Files
+
+- **[filename.ext](./filename.ext)** - Brief description
+- **[another-file.ext](./another-file.ext)** - Brief description
+
+## Subdirectories
+
+### subfolder/
+
+- **[file1.ext](./subfolder/file1.ext)** - Brief description
+- **[file2.ext](./subfolder/file2.ext)** - Brief description
+
+### another-folder/
+
+- **[file3.ext](./another-folder/file3.ext)** - Brief description
+```
+
+
+## HALT CONDITIONS
+
+- HALT if target directory does not exist or is inaccessible
+- HALT if user does not have write permissions to create index.md
+
+
+## VALIDATION
+
+- Use relative paths starting with ./
+- Group similar files together
+- Read file contents to generate accurate descriptions - don't guess from filenames
+- Keep descriptions concise but informative (3-10 words)
+- Sort alphabetically within groups
+- Skip hidden files (starting with .) unless specified

package/.opencode/skills/bmad-init/SKILL.md

@@ -0,0 +1,100 @@
+---
+name: bmad-init
+description: "Initialize BMad project configuration and load config variables. Use when any skill needs module-specific configuration values, or when setting up a new BMad project."
+argument-hint: "[--module=module_code] [--vars=var1:default1,var2] [--skill-path=/path/to/calling/skill]"
+---
+
+## Overview
+
+This skill is the configuration entry point for all BMad skills. It has two modes:
+
+- **Fast path**: Config exists for the requested module — returns vars as JSON. Done.
+- **Init path**: Config is missing — walks the user through configuration, writes config files, then returns vars.
+
+Every BMad skill should call this on activation to get its config vars. The caller never needs to know whether init happened — they just get their config back.
+
+The script `bmad_init.py` is located in this skill's `scripts/` directory. Locate and run it using python for all commands below.
+
+## On Activation — Fast Path
+
+Run the `bmad_init.py` script with the `load` subcommand. Pass `--project-root` set to the project root directory.
+
+- If a module code was provided by the calling skill, include `--module {module_code}`
+- To load all vars, include `--all`
+- To request specific variables with defaults, use `--vars var1:default1,var2`
+- If no module was specified, omit `--module` to get core vars only
+
+**If the script returns JSON vars** — store them as `{var-name}` and return to the calling skill. Done.
+
+**If the script returns an error or `init_required`** — proceed to the Init Path below.
+
+## Init Path — First-Time Setup
+
+When the fast path fails (config missing for a module), run this init flow.
+
+### Step 1: Check what needs setup
+
+Run `bmad_init.py` with the `check` subcommand, passing `--module {module_code}`, `--skill-path {calling_skill_path}`, and `--project-root`.
+
+The response tells you what's needed:
+
+- `"status": "ready"` — Config is fine. Re-run load.
+- `"status": "no_project"` — Can't find project root. Ask user to confirm the project path.
+- `"status": "core_missing"` — Core config doesn't exist. Must ask core questions first.
+- `"status": "module_missing"` — Core exists but module config doesn't. Ask module questions.
+
+The response includes:
+- `core_module` — Core module.yaml questions (when core setup needed)
+- `target_module` — Target module.yaml questions (when module setup needed, discovered from `--skill-path` or `_bmad/{module}/`)
+- `core_vars` — Existing core config values (when core exists but module doesn't)
+
+### Step 2: Ask core questions (if `core_missing`)
+
+The check response includes `core_module` with header, subheader, and variable definitions.
+
+1. Show the `header` and `subheader` to the user
+2. For each variable, present the `prompt` and `default`
+3. For variables with `single-select`, show the options as a numbered list
+4. For variables with multi-line `prompt` (array), show all lines
+5. Let the user accept defaults or provide values
+
+### Step 3: Ask module questions (if module was requested)
+
+The check response includes `target_module` with the module's questions. Variables may reference core answers in their defaults (e.g., `{output_folder}`).
+
+1. Resolve defaults by running `bmad_init.py` with the `resolve-defaults` subcommand, passing `--module {module_code}`, `--core-answers '{core_answers_json}'`, and `--project-root`
+2. Show the module's `header` and `subheader`
+3. For each variable, present the prompt with resolved default
+4. For `single-select` variables, show options as a numbered list
+
+### Step 4: Write config
+
+Collect all answers and run `bmad_init.py` with the `write` subcommand, passing `--answers '{all_answers_json}'` and `--project-root`.
+
+The `--answers` JSON format:
+
+```json
+{
+  "core": {
+    "user_name": "BMad",
+    "communication_language": "English",
+    "document_output_language": "English",
+    "output_folder": "_bmad-output"
+  },
+  "bmb": {
+    "bmad_builder_output_folder": "_bmad-output/skills",
+    "bmad_builder_reports": "_bmad-output/reports"
+  }
+}
+```
+
+Note: Pass the **raw user answers** (before result template expansion). The script applies result templates and `{project-root}` expansion when writing.
+
+The script:
+- Creates `_bmad/core/config.yaml` with core values (if core answers provided)
+- Creates `_bmad/{module}/config.yaml` with core values + module values (result-expanded)
+- Creates any directories listed in the module.yaml `directories` array
+
+### Step 5: Return vars
+
+After writing, re-run `bmad_init.py` with the `load` subcommand (same as the fast path) to return resolved vars. Store returned vars as `{var-name}` and return them to the calling skill.

package/.opencode/skills/bmad-init/resources/core-module.yaml

@@ -0,0 +1,25 @@
+code: core
+name: "BMad Core Module"
+
+header: "BMad Core Configuration"
+subheader: "Configure the core settings for your BMad installation.\nThese settings will be used across all installed bmad skills, workflows, and agents."
+
+user_name:
+  prompt: "What should agents call you? (Use your name or a team name)"
+  default: "BMad"
+  result: "{value}"
+
+communication_language:
+  prompt: "What language should agents use when chatting with you?"
+  default: "English"
+  result: "{value}"
+
+document_output_language:
+  prompt: "Preferred document output language?"
+  default: "English"
+  result: "{value}"
+
+output_folder:
+  prompt: "Where should output files be saved?"
+  default: "_bmad-output"
+  result: "{project-root}/{value}"