bmad-method-quarkus 1.0.0 → 1.0.2

package/src/commands/dev-all.md

@@ -0,0 +1,105 @@
+---
+description: Batch-run the BMAD dev-story workflow across all pending stories, with per-epic checkpoints and optional commit-per-story.
+argument-hint: "[commit] [skip-review] [checkpoint] [epic=<id>]  e.g. `/dev-all` or `/dev-all commit skip-review` or `/dev-all checkpoint epic=3`"
+allowed-tools: Read, Edit, Write, Bash(git status:*), Bash(git add:*), Bash(git commit:*), Bash(git log:*)
+---
+
+# Batch develop BMAD stories
+
+You are running an **unattended batch** of the BMAD dev-story workflow. Work through
+stories one at a time (preserving per-story context), but do **not** stop for
+confirmation between stories. Only the per-epic checkpoint below is a hard stop.
+
+## The BMAD build cycle — run these EXACT commands per story
+
+For each story, run the DEV agent's three-step cycle, in order:
+
+1. `bmad-create-story`  — create the story file from the epic
+2. `bmad-dev-story`     — implement the story
+3. `bmad-code-review`   — quality validation
+
+Invoke these real BMAD workflows — do NOT improvise your own create/implement/review
+steps. They carry the architecture context and dev-notes inheritance that keep output
+coherent.
+
+> **Note on "fresh chats":** BMAD's docs say to repeat this cycle *in a fresh chat per
+> story*, so each story gets a clean context window. This batch command runs multiple
+> stories in one session, which sacrifices that guarantee for hands-off throughput.
+> That's an acceptable trade for a small/well-understood epic. For a large epic, prefer
+> running the cycle manually per story, or use the per-epic checkpoint below to resume
+> each epic in a fresh session.
+
+- **State file:** `sprint-status.yaml` (source of truth for story status)
+- **Epic definitions:** `epics.md`
+
+## Arguments
+
+Parse `$ARGUMENTS`:
+- `commit`  → enable **commit-per-story** (off by default). When enabled, after a
+  story passes review, run `git add -A && git commit` with a message like
+  `feat(<epic>): <story-id> <short title>`.
+- `epic=<id>` → restrict the batch to a single epic.
+- `checkpoint` → **pause** for confirmation at each epic boundary (off by default —
+  by default the run is fully unattended and does NOT stop between epics).
+- `skip-review` → skip the `bmad-code-review` step. The per-story cycle becomes
+  `bmad-create-story` → `bmad-dev-story` only.
+
+**Default (no `epic=` given): process ALL epics**, in order, running every not-done
+story across the whole project **without stopping between epics**. So bare `/dev-all`
+develops everything unattended; `/dev-all epic=2` develops only epic 2; add
+`checkpoint` if you want a pause + summary before each new epic.
+
+## Loop
+
+1. **Read `sprint-status.yaml`.** Build the ordered list of stories whose status is
+   NOT `done` (e.g. `pending`, `ready`, `in-progress`, `blocked` should be surfaced —
+   see step 6 for blocked). Respect the `epic=` filter if present.
+
+2. **If the list is empty**, report "All stories already done" and stop.
+
+3. **For each story, in order:**
+   a. Announce which story you're starting (id + title).
+   b. Run the BMAD cycle for that story, in order:
+      `bmad-create-story` → `bmad-dev-story` → `bmad-code-review`.
+      **If `skip-review` is set, omit `bmad-code-review`** (run create → dev only).
+   c. If review passed (or `skip-review` is set and implementation completed without
+      error), set that story's status to `done` in `sprint-status.yaml`.
+   d. **If commit-per-story is enabled**, stage and commit (see Arguments). Keep each
+      commit scoped to that one story so a bad story can be rolled back in isolation.
+   e. Continue to the next story WITHOUT asking for confirmation.
+
+4. **Per-epic boundary.** When you finish the last story of an epic and more epics
+   remain, post a short summary: epic name, stories completed/blocked, tests added,
+   files touched, and anything that looked off (scope creep, tests worked around,
+   architectural surprises).
+   - **Default: do NOT stop.** Print the summary and immediately continue into the
+     next epic without asking for confirmation.
+   - **Only if `checkpoint` is set:** stop after the summary and wait for my go-ahead
+     before starting the next epic.
+
+5. **Context hygiene on long runs.** If you notice your context getting large mid-run,
+   say so in the nearest epic-boundary summary and recommend I resume the remaining
+   epics in a fresh session. Don't silently push through degraded context. (This is the
+   main risk of a fully unattended all-epics run — flag it rather than hide it.)
+
+6. **Error / blocked handling.** If a story fails `bmad-code-review` twice, or you hit an error you
+   can't resolve, or a dependency is missing:
+   - Set its status to `blocked` in `sprint-status.yaml` with a one-line reason.
+   - Do NOT mark it `done`. Do NOT keep retrying indefinitely.
+   - Skip it and continue with the remaining stories, then report all blocked stories
+     in the next checkpoint / final summary.
+
+## Final summary
+
+When every eligible story is `done` or `blocked`, stop and report:
+- Count done vs. blocked, grouped by epic
+- List of blocked stories with reasons
+- Commits made (if commit-per-story was on)
+- Any follow-ups I should handle manually
+
+## Guardrails
+
+- Never mark a story `done` unless its review actually passed.
+- Never force-push or rewrite history. Commits only, and only when `commit` is set.
+- If `sprint-status.yaml` and `epics.md` disagree about which stories exist, trust
+  `sprint-status.yaml` for status but flag the mismatch in the summary.

package/src/commands/quarkus-all.md

@@ -0,0 +1,156 @@
+---
+description: Batch-build BMAD stories through Marcus (bmad-quarkus-build) — one skill invocation per story instead of the create-story/dev-story/code-review cycle.
+argument-hint: "[commit] [checkpoint] [review] [force] [dry-run] [epic=<id>] [limit=<n>]  e.g. `/quarkus-all` or `/quarkus-all commit epic=20` or `/quarkus-all dry-run`"
+allowed-tools: Read, Edit, Write, Bash(git status:*), Bash(git add:*), Bash(git commit:*), Bash(git log:*), Bash(git diff:*), Bash(./mvnw:*), Bash(mvn:*)
+---
+
+# Batch build BMAD stories with the Quarkus agent
+
+You are running an **unattended batch** of Quarkus story implementation. Work through
+stories one at a time (preserving per-story context), but do **not** stop for
+confirmation between stories. Only the per-epic checkpoint below is a hard stop.
+
+## The cycle — ONE command per story
+
+For each story, invoke exactly **one** skill:
+
+```
+bmad-quarkus-build   →  "Marcus, implement story <story-key>"
+```
+
+That is the whole per-story cycle. **Do NOT run `bmad-create-story`, `bmad-dev-story`,
+or `bmad-code-review` as separate steps** — Marcus owns the full loop (story
+preparation → red-green-refactor implementation → self-review against the ACs) and
+routes into `bmad-build` plus whichever of the 7 Quarkus domain standards the story
+touches (`quarkus-hexagonal-core`, `quarkus-sql-jdbc-agroal`,
+`quarkus-error-handling-i18n`, `quarkus-openapi-tmforum`, `quarkus-grpc-services`,
+`quarkus-kafka-messaging`, `quarkus-observability-otel`). Splitting the cycle back into
+three commands loses that routing and the native-image/hexagonal review that comes with it.
+
+Pass the story key in the invocation so Marcus dispatches directly instead of rendering
+his menu (his activation Step 8 skips the menu when the intent is already named).
+
+Marcus stays active across stories once activated — do not re-run his activation
+greeting for every story, just hand him the next story key.
+
+- **State file:** `_bmad-output/implementation-artifacts/sprint-status.yaml` (source of truth for story status)
+- **Story files:** `_bmad-output/implementation-artifacts/<story-key>.md`
+- **Epic definitions:** `governance/_bmad-output/planning-artifacts/epics.md`
+
+> **Note on "fresh chats":** BMAD's docs say to repeat the build cycle *in a fresh chat
+> per story*, so each story gets a clean context window. This batch command runs multiple
+> stories in one session, which sacrifices that guarantee for hands-off throughput. That's
+> an acceptable trade for a small/well-understood epic. For a large epic, prefer running
+> `bmad-quarkus-build` manually per story, or use the per-epic checkpoint below to resume
+> each epic in a fresh session.
+
+## Arguments
+
+Parse `$ARGUMENTS`:
+- `commit` → enable **commit-per-story** (off by default). After a story passes, run
+  `git add -A && git commit` with a message like `feat(epic-20): 20-1 create a digital identity`.
+- `epic=<id>` → restrict the batch to a single epic (`epic=20`, `epic=256`).
+- `limit=<n>` → stop after `n` stories have been completed this run.
+- `checkpoint` → **pause** for confirmation at each epic boundary (off by default — by
+  default the run is fully unattended and does NOT stop between epics).
+- `review` → add a separate `bmad-code-review` pass **after** Marcus finishes each story.
+  Off by default: Marcus already reviews his own output, and this is the one case where a
+  second command per story is intentional (fresh-context adversarial review).
+- `force` → override the build-eligibility gate below. Requires that I said so explicitly;
+  never infer it.
+- `dry-run` → print the ordered story list, the eligibility verdict per epic, and stop.
+  Change nothing. Use this first on any wide run.
+
+**Default (no `epic=` given): process all *build-eligible* epics**, in order, running every
+not-done story **without stopping between epics**.
+
+## Build eligibility — read this BEFORE touching any story
+
+`sprint-status.yaml` carries BUILD-STATUS markers as trailing comments on epic headings.
+**They are not statuses.** A `backlog` status on a marked epic means NOT STARTED — it does
+**not** mean cleared to start.
+
+- `[V1]` → **build-ready.** Epics 20, 21, 22, 23, 24, 26, 28, 30, 31.
+- `[BUILD-PROHIBITED]` → **skip.** Epics 32, 33, 34, 35, 36 (36 also reassigned to BC-05).
+  Feature files exist, but building is forbidden — ADR-024 requires a P2→P10 re-run, never
+  a local fix.
+- `[BUILD-PROHIBITED in part]` → **skip epic 27** unless I name a specific permitted story.
+- `[UNCLASSIFIED]` → **skip.** Epics 25, 29, 37–45, 262, 263. Per OI-50 the build decision
+  belongs to the Product Owner + Architect Lead, not to us.
+- `[BLOCKED]` → **skip.** Epics 256, 263.
+
+Re-read the markers from the file rather than trusting this list — the file is the source of
+truth and its scope can change. If `epic=<id>` names a non-eligible epic, refuse and say
+which marker blocks it; only `force` overrides, and even then print the marker you are
+overriding.
+
+The whole file is scoped to **BC-01 only** (29 of the 263 epics in `epics.md`). The other
+epics are absent by design — never treat their absence as done or as something to go build.
+
+## Loop
+
+1. **Read `sprint-status.yaml`.** Build the ordered list of stories whose status is NOT
+   `done`. Legal story statuses in this file are `backlog`, `ready-for-dev`, `in-progress`,
+   `review`, `done`. Apply the eligibility gate, then the `epic=` filter, then `limit=`.
+
+2. **If the list is empty**, report "No eligible stories pending" and stop.
+
+3. **For each story, in order:**
+   a. Announce which story you're starting (key + title + epic).
+   b. Invoke `bmad-quarkus-build` with that story key. One invocation. Nothing else.
+   c. If `review` is set, run `bmad-code-review` on the resulting diff.
+   d. On success — ACs met, tests written test-first and passing — set the story's status to
+      `done` in `sprint-status.yaml` and update `last_updated`.
+   e. If it's the epic's last story and all its stories are now `done`, set `epic-<id>: done`.
+      Set `epic-<id>: in-progress` when starting the epic's first story.
+   f. **If commit-per-story is enabled**, stage and commit. Keep each commit scoped to that
+      one story so a bad story can be rolled back in isolation.
+   g. Continue to the next story WITHOUT asking for confirmation.
+
+4. **Per-epic boundary.** When you finish the last story of an epic and more epics remain,
+   post a short summary: epic, stories completed/held, tests added, files touched, and
+   anything that looked off (scope creep, tests worked around, hexagonal or native-image
+   surprises, a domain standard that contradicted the story).
+   - **Default: do NOT stop.** Print the summary and continue into the next epic.
+   - **Only if `checkpoint` is set:** stop after the summary and wait for my go-ahead.
+
+5. **Context hygiene on long runs.** If your context is getting large mid-run, say so in the
+   nearest epic-boundary summary and recommend resuming the remaining epics in a fresh
+   session. Don't silently push through degraded context — that's the main risk of a fully
+   unattended all-epics run.
+
+6. **Error / held handling.** If Marcus can't complete a story, a second attempt fails, or a
+   dependency is missing:
+   - **Do not invent a `blocked` status** — this file's state machine has no such value and
+     the header says so explicitly. Leave the story at its current status and append a
+     trailing comment on its line: `# HELD 2026-xx-xx: <one-line reason>`.
+   - Do NOT mark it `done`. Do NOT retry indefinitely (two attempts max).
+   - Skip it and continue, then report all held stories in the next checkpoint / final summary.
+
+## Final summary
+
+When every eligible story is `done` or held, stop and report:
+- Count done vs. held, grouped by epic
+- Held stories with reasons
+- Epics skipped by the eligibility gate, with the marker that skipped them
+- Commits made (if `commit` was on)
+- Any follow-ups I should handle manually
+
+## Guardrails
+
+- **One `bmad-quarkus-build` invocation per story.** Never decompose it back into
+  `bmad-create-story` → `bmad-dev-story` → `bmad-code-review`.
+- Never mark a story `done` unless its tests actually pass and every AC is met. ACs in these
+  stories are verbatim Gherkin — do not edit, reword, or renumber them.
+- Never start a story in a `[BUILD-PROHIBITED]`, `[BUILD-PROHIBITED in part]`,
+  `[UNCLASSIFIED]`, or `[BLOCKED]` epic without explicit `force`.
+- FR-1243 forbids marking anything Done while a blocker is in scope, and the 2026-08-13
+  readiness report reads NEEDS WORK. This command asserts no gate verdict and closes no open
+  item — it only advances story statuses it actually completed.
+- Never force-push or rewrite history. Commits only, and only when `commit` is set.
+- `sprint-status.yaml` has a stale `story_location:` pointing at a macOS path
+  (`/Users/diego/...`). Trust the real repo path `_bmad-output/implementation-artifacts`;
+  flag the mismatch in the final summary rather than editing it mid-run.
+- If `sprint-status.yaml` and `epics.md` disagree about which stories exist, trust
+  `sprint-status.yaml` for status and flag the mismatch. Declared-vs-actual epic count gaps
+  (the file notes one) are a PM finding — report, don't reconcile.

package/tools/installer/ide/_config-driven.js

@@ -4,6 +4,7 @@ const yaml = require('yaml');
 const prompts = require('../prompts');
 const csv = require('csv-parse/sync');
 const { BMAD_FOLDER_NAME } = require('./shared/path-utils');
+const { getSourcePath } = require('../project-root');
 const { getInstalledCanonicalIds, isBmadOwnedEntry } = require('./shared/installed-skills');
 
 // Reserved OpenCode slash commands. A skill whose canonicalId collides with
@@ -255,6 +256,7 @@ class ConfigDrivenIdeSetup {
 
     if (config.commands_target_dir) {
       results.commands = await this.installCommandPointers(projectDir, bmadDir, config, options);
+      results.customCommands = await this.installCustomCommands(projectDir, config, options);
     }
 
     await this.printSummary(results, target_dir, options);
@@ -301,6 +303,11 @@ class ConfigDrivenIdeSetup {
       fallbackDescription: 0,
     };
 
+    // If filtered to custom commands only, skip generating pointer files for skills
+    if (config.commands_filter === 'custom-only') {
+      return result;
+    }
+
     const csvPath = path.join(bmadDir, '_config', 'skill-manifest.csv');
     if (!(await fs.pathExists(csvPath))) return result;
 
@@ -404,6 +411,42 @@ class ConfigDrivenIdeSetup {
     return result;
   }
 
+  /**
+   * Copy static/custom command markdown files from src/commands/ into commands_target_dir.
+   * @param {string} projectDir - Project directory
+   * @param {Object} config - Installer config; reads commands_target_dir.
+   * @param {Object} options - Setup options.
+   * @returns {Promise<Object>} { copied, writeFailures }
+   */
+  async installCustomCommands(projectDir, config, options = {}) {
+    const result = { copied: 0, writeFailures: 0 };
+    if (!config.commands_target_dir) return result;
+
+    const sourceCommandsDir = getSourcePath('commands');
+    if (!(await fs.pathExists(sourceCommandsDir))) return result;
+
+    const commandsPath = path.join(projectDir, config.commands_target_dir);
+    await fs.ensureDir(commandsPath);
+
+    const files = await fs.readdir(sourceCommandsDir);
+    for (const file of files) {
+      if (file.endsWith('.md')) {
+        const srcFile = path.join(sourceCommandsDir, file);
+        const destFile = path.join(commandsPath, file);
+        try {
+          await fs.copy(srcFile, destFile, { overwrite: true });
+          result.copied++;
+        } catch (error) {
+          result.writeFailures++;
+          if (!options.silent) {
+            await prompts.log.warn(`Failed to copy custom command ${file}: ${error.message}`);
+          }
+        }
+      }
+    }
+    return result;
+  }
+
   /**
    * Install verbatim native SKILL.md directories from skill-manifest.csv.
    * Copies the entire source directory as-is into the IDE skill directory.

package/tools/installer/ide/platform-codes.yaml

@@ -62,6 +62,8 @@ platforms:
     installer:
       target_dir: .claude/skills
       global_target_dir: ~/.claude/skills
+      commands_target_dir: .claude/commands
+      commands_filter: custom-only
 
   cline:
     name: "Cline"