bms-speckit-plugin 3.9.0 → 4.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "bms-speckit",
|
|
3
|
-
"version": "
|
|
4
|
-
"description": "
|
|
3
|
+
"version": "4.0.0",
|
|
4
|
+
"description": "Chain-orchestrated development pipeline with per-step error handling. /bms-speckit runs brainstorm → constitution → specify → plan → tasks → analyze → implement → verify.",
|
|
5
5
|
"author": {
|
|
6
6
|
"name": "manoirx"
|
|
7
7
|
},
|
|
@@ -0,0 +1,247 @@
|
|
|
1
|
+
# BMS Speckit Development Pipeline — Chain Blueprint
|
|
2
|
+
# Compatible with Skene Cookbook chain pattern (https://github.com/SkeneTechnologies/skene-cookbook)
|
|
3
|
+
#
|
|
4
|
+
# This blueprint defines the chain sequence, I/O contracts, error handling,
|
|
5
|
+
# and timeout constraints for each step. The SKILL.md orchestrator executes
|
|
6
|
+
# this chain via Claude Code's Skill tool.
|
|
7
|
+
|
|
8
|
+
id: bms_speckit_development_pipeline
|
|
9
|
+
version: 4.0.0
|
|
10
|
+
name: BMS Speckit Automated Development Pipeline
|
|
11
|
+
description: >
|
|
12
|
+
Full engineering workflow from requirement to verified implementation.
|
|
13
|
+
Chains brainstorming, constitution, specification, planning, task generation,
|
|
14
|
+
analysis, implementation (TDD), and final verification.
|
|
15
|
+
category: Development
|
|
16
|
+
|
|
17
|
+
# ─── Chain Sequence ────────────────────────────────────────────────────────────
|
|
18
|
+
|
|
19
|
+
chain_sequence:
|
|
20
|
+
|
|
21
|
+
# ── Phase 1: Specification & Planning (subagent context) ──────────────────
|
|
22
|
+
|
|
23
|
+
- step_id: step_0_brainstorm
|
|
24
|
+
skill_id: superpowers.brainstorm
|
|
25
|
+
action: execute
|
|
26
|
+
phase: 1
|
|
27
|
+
description: Explore intent, requirements, and design before implementation
|
|
28
|
+
timeout_seconds: 300
|
|
29
|
+
input:
|
|
30
|
+
requirement: "$ARGUMENTS"
|
|
31
|
+
output:
|
|
32
|
+
artifacts: [detailed_specification]
|
|
33
|
+
error_handling:
|
|
34
|
+
on_failure: stop
|
|
35
|
+
max_retries: 1
|
|
36
|
+
opinionated_prompts:
|
|
37
|
+
system_context: >
|
|
38
|
+
Write a detailed specification from the user's requirement.
|
|
39
|
+
Explore edge cases, constraints, and design alternatives.
|
|
40
|
+
|
|
41
|
+
- step_id: step_1_constitution
|
|
42
|
+
skill_id: speckit.constitution
|
|
43
|
+
action: execute
|
|
44
|
+
phase: 1
|
|
45
|
+
description: Establish and enforce engineering principles
|
|
46
|
+
timeout_seconds: 300
|
|
47
|
+
input:
|
|
48
|
+
principles: >
|
|
49
|
+
Establish and enforce a comprehensive set of engineering principles
|
|
50
|
+
that prioritize high code quality, strict adherence to Test-Driven
|
|
51
|
+
Development (TDD) practices, and well-defined testing standards across
|
|
52
|
+
unit, component, integration, and API levels to ensure system reliability
|
|
53
|
+
and maintainability, maintain a consistent, user-friendly, and professional
|
|
54
|
+
user interface aligned with strong user experience (UX) guidelines,
|
|
55
|
+
optimize application performance through efficient architecture and
|
|
56
|
+
resource management; enforce disciplined version control practices with
|
|
57
|
+
frequent, atomic commits to minimize risk and improve traceability,
|
|
58
|
+
promote the development and reuse of modular components and functions
|
|
59
|
+
while centralizing business logic to avoid duplication and ensure
|
|
60
|
+
consistency, provide clear, informative user feedback and progress
|
|
61
|
+
reporting throughout system interactions, and leverage all available
|
|
62
|
+
tools, frameworks, and domain-specific expertise to support developers
|
|
63
|
+
in delivering robust, scalable, and high-quality applications.
|
|
64
|
+
output:
|
|
65
|
+
artifacts: [specs/constitution.md]
|
|
66
|
+
error_handling:
|
|
67
|
+
on_failure: stop
|
|
68
|
+
max_retries: 1
|
|
69
|
+
opinionated_prompts:
|
|
70
|
+
system_context: >
|
|
71
|
+
TDD is non-negotiable. Constitution must enforce testing at all levels,
|
|
72
|
+
atomic commits, reusable components, and centralized business logic.
|
|
73
|
+
|
|
74
|
+
- step_id: step_2_claude_md_sync
|
|
75
|
+
skill_id: internal.claude_md_verify
|
|
76
|
+
action: execute
|
|
77
|
+
phase: 1
|
|
78
|
+
description: Verify CLAUDE.md complies with constitution
|
|
79
|
+
timeout_seconds: 120
|
|
80
|
+
input:
|
|
81
|
+
constitution_path: specs/constitution.md
|
|
82
|
+
target_path: CLAUDE.md
|
|
83
|
+
error_handling:
|
|
84
|
+
on_failure: continue
|
|
85
|
+
max_retries: 1
|
|
86
|
+
opinionated_prompts:
|
|
87
|
+
system_context: >
|
|
88
|
+
Read CLAUDE.md and verify it complies with specs/constitution.md.
|
|
89
|
+
Update CLAUDE.md if it conflicts with or is missing constitution rules.
|
|
90
|
+
|
|
91
|
+
- step_id: step_3_specify
|
|
92
|
+
skill_id: speckit.specify
|
|
93
|
+
action: execute
|
|
94
|
+
phase: 1
|
|
95
|
+
description: Create feature specification from requirement
|
|
96
|
+
timeout_seconds: 300
|
|
97
|
+
input:
|
|
98
|
+
requirement: "$ARGUMENTS"
|
|
99
|
+
output:
|
|
100
|
+
artifacts: [specs/*/spec.md]
|
|
101
|
+
error_handling:
|
|
102
|
+
on_failure: stop
|
|
103
|
+
max_retries: 2
|
|
104
|
+
opinionated_prompts:
|
|
105
|
+
system_context: >
|
|
106
|
+
Generate a complete, testable specification. Include acceptance criteria,
|
|
107
|
+
data models, API contracts, and edge cases.
|
|
108
|
+
|
|
109
|
+
- step_id: step_4_plan
|
|
110
|
+
skill_id: speckit.plan
|
|
111
|
+
action: execute
|
|
112
|
+
phase: 1
|
|
113
|
+
description: Generate implementation plan from specification
|
|
114
|
+
timeout_seconds: 300
|
|
115
|
+
input:
|
|
116
|
+
source: "{{step_3_specify.artifacts}}"
|
|
117
|
+
output:
|
|
118
|
+
artifacts: [specs/*/plan.md]
|
|
119
|
+
error_handling:
|
|
120
|
+
on_failure: stop
|
|
121
|
+
max_retries: 2
|
|
122
|
+
opinionated_prompts:
|
|
123
|
+
system_context: >
|
|
124
|
+
Plan in ordered steps. Include file paths, component boundaries,
|
|
125
|
+
test strategy, and rollback considerations.
|
|
126
|
+
|
|
127
|
+
- step_id: step_5_tasks
|
|
128
|
+
skill_id: speckit.tasks
|
|
129
|
+
action: execute
|
|
130
|
+
phase: 1
|
|
131
|
+
description: Generate dependency-ordered task list
|
|
132
|
+
timeout_seconds: 300
|
|
133
|
+
input:
|
|
134
|
+
source: "{{step_4_plan.artifacts}}"
|
|
135
|
+
output:
|
|
136
|
+
artifacts: [specs/*/tasks.md]
|
|
137
|
+
error_handling:
|
|
138
|
+
on_failure: stop
|
|
139
|
+
max_retries: 2
|
|
140
|
+
opinionated_prompts:
|
|
141
|
+
system_context: >
|
|
142
|
+
Tasks must be atomic, dependency-ordered, and each independently testable.
|
|
143
|
+
Include clear acceptance criteria per task.
|
|
144
|
+
|
|
145
|
+
- step_id: step_6_analyze
|
|
146
|
+
skill_id: speckit.analyze
|
|
147
|
+
action: execute
|
|
148
|
+
phase: 1
|
|
149
|
+
description: Cross-artifact consistency and quality check
|
|
150
|
+
timeout_seconds: 300
|
|
151
|
+
input:
|
|
152
|
+
source: "{{step_5_tasks.artifacts}}"
|
|
153
|
+
output:
|
|
154
|
+
artifacts: [analysis_report]
|
|
155
|
+
error_handling:
|
|
156
|
+
on_failure: continue
|
|
157
|
+
max_retries: 1
|
|
158
|
+
opinionated_prompts:
|
|
159
|
+
system_context: >
|
|
160
|
+
Check spec ↔ plan ↔ tasks consistency. Flag gaps, contradictions,
|
|
161
|
+
and missing test coverage. Non-destructive — report only.
|
|
162
|
+
|
|
163
|
+
- step_id: step_7_commit
|
|
164
|
+
skill_id: internal.git_commit_push
|
|
165
|
+
action: execute
|
|
166
|
+
phase: 1
|
|
167
|
+
description: Commit all specification artifacts and push
|
|
168
|
+
timeout_seconds: 120
|
|
169
|
+
error_handling:
|
|
170
|
+
on_failure: continue
|
|
171
|
+
max_retries: 1
|
|
172
|
+
opinionated_prompts:
|
|
173
|
+
system_context: >
|
|
174
|
+
Commit all files in specs/ with a descriptive message.
|
|
175
|
+
Push to remote if configured.
|
|
176
|
+
|
|
177
|
+
# ── Phase 2: Implementation (main context) ────────────────────────────────
|
|
178
|
+
|
|
179
|
+
- step_id: step_8_compact
|
|
180
|
+
skill_id: internal.compact
|
|
181
|
+
action: execute
|
|
182
|
+
phase: 2
|
|
183
|
+
description: Free context window before implementation
|
|
184
|
+
timeout_seconds: 30
|
|
185
|
+
error_handling:
|
|
186
|
+
on_failure: continue
|
|
187
|
+
max_retries: 0
|
|
188
|
+
|
|
189
|
+
- step_id: step_9_implement
|
|
190
|
+
skill_id: speckit.implement
|
|
191
|
+
action: execute_loop
|
|
192
|
+
phase: 2
|
|
193
|
+
description: Execute all tasks with TDD workflow via ralph-loop
|
|
194
|
+
timeout_seconds: 3600
|
|
195
|
+
input:
|
|
196
|
+
tasks_path: "specs/*/tasks.md"
|
|
197
|
+
loop_engine: ralph-loop
|
|
198
|
+
completion_promise: "FINISHED"
|
|
199
|
+
max_iterations: 10
|
|
200
|
+
output:
|
|
201
|
+
artifacts: [source_code, tests, commits]
|
|
202
|
+
error_handling:
|
|
203
|
+
on_failure: continue
|
|
204
|
+
max_retries: 3
|
|
205
|
+
opinionated_prompts:
|
|
206
|
+
system_context: >
|
|
207
|
+
Systematically execute speckit.implement to complete every task.
|
|
208
|
+
Enforce TDD: write and pass tests before marking any task complete.
|
|
209
|
+
Ensure code quality through linting, static analysis, and consistent
|
|
210
|
+
architecture with reusable components and centralized business logic.
|
|
211
|
+
Maintain atomic commits after each successful task.
|
|
212
|
+
After all tasks: invoke speckit.analyze for full validation,
|
|
213
|
+
apply improvements, re-run all tests, confirm zero regression.
|
|
214
|
+
Only output FINISHED after everything is validated.
|
|
215
|
+
|
|
216
|
+
- step_id: step_10_verify
|
|
217
|
+
skill_id: speckit.analyze
|
|
218
|
+
action: execute
|
|
219
|
+
phase: 2
|
|
220
|
+
description: Final validation pass — confirm production-grade quality
|
|
221
|
+
timeout_seconds: 300
|
|
222
|
+
error_handling:
|
|
223
|
+
on_failure: stop
|
|
224
|
+
max_retries: 1
|
|
225
|
+
opinionated_prompts:
|
|
226
|
+
system_context: >
|
|
227
|
+
Final gate. Verify all tasks completed, tests passing,
|
|
228
|
+
no regressions, code quality standards met.
|
|
229
|
+
|
|
230
|
+
# ─── Metadata ──────────────────────────────────────────────────────────────────
|
|
231
|
+
|
|
232
|
+
metadata:
|
|
233
|
+
author: manoirx
|
|
234
|
+
created_at: "2026-03-29"
|
|
235
|
+
tags: [speckit, tdd, workflow, development, chain, engineering]
|
|
236
|
+
estimated_duration_seconds: 6000
|
|
237
|
+
phases:
|
|
238
|
+
phase_1:
|
|
239
|
+
name: Specification & Planning
|
|
240
|
+
steps: [step_0 through step_7]
|
|
241
|
+
execution: subagent
|
|
242
|
+
reason: Preserve main context window for implementation
|
|
243
|
+
phase_2:
|
|
244
|
+
name: Implementation & Verification
|
|
245
|
+
steps: [step_8 through step_10]
|
|
246
|
+
execution: main_context
|
|
247
|
+
reason: Implementation needs full tool access and ralph-loop
|
package/package.json
CHANGED
|
@@ -1,10 +1,11 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "bms-speckit-plugin",
|
|
3
|
-
"version": "
|
|
4
|
-
"description": "
|
|
3
|
+
"version": "4.0.0",
|
|
4
|
+
"description": "Chain-orchestrated development pipeline: /bms-speckit takes requirements and runs brainstorm → constitution → specify → plan → tasks → analyze → implement → verify with per-step error handling",
|
|
5
5
|
"files": [
|
|
6
6
|
".claude-plugin/",
|
|
7
|
-
"skills/"
|
|
7
|
+
"skills/",
|
|
8
|
+
"blueprints/"
|
|
8
9
|
],
|
|
9
10
|
"keywords": [
|
|
10
11
|
"claude-code-plugin",
|
|
@@ -3,40 +3,111 @@ name: bms-speckit-auto
|
|
|
3
3
|
description: Full automated development workflow. This skill should be used when the user asks to "build an application", "create a dashboard", "develop a feature", "speckit", "bms-speckit", or provides a software requirement to implement end-to-end with TDD, specifications, and quality gates. Usage /bms-speckit:bms-speckit-auto <your requirement description>
|
|
4
4
|
---
|
|
5
5
|
|
|
6
|
-
# BMS Speckit —
|
|
6
|
+
# BMS Speckit — Chain Orchestrator
|
|
7
7
|
|
|
8
|
-
|
|
8
|
+
Chain blueprint: `blueprints/bms-speckit-pipeline.yaml`
|
|
9
9
|
|
|
10
|
-
##
|
|
10
|
+
## Execution Rules
|
|
11
11
|
|
|
12
|
-
|
|
12
|
+
1. Execute steps **sequentially** in chain order — never skip steps
|
|
13
|
+
2. Use the **Skill tool** for all skill invocations (no slash commands in subagents)
|
|
14
|
+
3. On step failure, check the **error policy** before proceeding:
|
|
15
|
+
- `on_failure: stop` → halt the chain and report which step failed
|
|
16
|
+
- `on_failure: continue` → log the failure and proceed to next step
|
|
17
|
+
4. Pass `$ARGUMENTS` (the user's requirement) only to steps that accept `requirement` input (step 0 and step 3)
|
|
18
|
+
5. Do NOT ask for confirmation between steps
|
|
13
19
|
|
|
14
|
-
|
|
20
|
+
---
|
|
15
21
|
|
|
16
|
-
|
|
17
|
-
You are running the BMS Speckit specification and planning phase. Execute these steps in order using the Skill tool. Do NOT ask for confirmation.
|
|
22
|
+
## Phase 1: Specification & Planning
|
|
18
23
|
|
|
19
|
-
|
|
24
|
+
> **Execution context:** Dispatch ALL Phase 1 steps in a single subagent to preserve the main context window for implementation.
|
|
20
25
|
|
|
21
|
-
|
|
26
|
+
Subagent prompt:
|
|
22
27
|
|
|
23
|
-
|
|
28
|
+
"""
|
|
29
|
+
You are running the BMS Speckit specification and planning chain. Execute each step in order using the Skill tool. Do NOT ask for confirmation. Follow error handling policies exactly.
|
|
30
|
+
|
|
31
|
+
### Step 0 — Brainstorm `[on_failure: STOP]`
|
|
32
|
+
- **Skill:** `superpowers.brainstorm`
|
|
33
|
+
- **Input:** "$ARGUMENTS"
|
|
34
|
+
- **Purpose:** Explore intent, requirements, design alternatives, and edge cases
|
|
35
|
+
- **Output:** Detailed specification document
|
|
36
|
+
- **Timeout:** 300s
|
|
37
|
+
|
|
38
|
+
### Step 1 — Constitution `[on_failure: STOP]`
|
|
39
|
+
- **Skill:** `speckit.constitution`
|
|
40
|
+
- **Input:** "Establish and enforce a comprehensive set of engineering principles that prioritize high code quality, strict adherence to Test-Driven Development (TDD) practices, and well-defined testing standards across unit, component, integration, and API levels to ensure system reliability and maintainability, maintain a consistent, user-friendly, and professional user interface aligned with strong user experience (UX) guidelines, optimize application performance through efficient architecture and resource management; enforce disciplined version control practices with frequent, atomic commits to minimize risk and improve traceability, promote the development and reuse of modular components and functions while centralizing business logic to avoid duplication and ensure consistency, provide clear, informative user feedback and progress reporting throughout system interactions, and leverage all available tools, frameworks, and domain-specific expertise to support developers in delivering robust, scalable, and high-quality applications."
|
|
41
|
+
- **Output:** `specs/constitution.md`
|
|
42
|
+
- **Timeout:** 300s
|
|
43
|
+
|
|
44
|
+
### Step 2 — CLAUDE.md Sync `[on_failure: CONTINUE]`
|
|
45
|
+
- **Action:** Read CLAUDE.md and verify it complies with the constitution in `specs/constitution.md`. Update CLAUDE.md if it conflicts with or is missing constitution rules.
|
|
46
|
+
- **Timeout:** 120s
|
|
47
|
+
|
|
48
|
+
### Step 3 — Specify `[on_failure: STOP]`
|
|
49
|
+
- **Skill:** `speckit.specify`
|
|
50
|
+
- **Input:** "$ARGUMENTS"
|
|
51
|
+
- **Output:** `specs/*/spec.md`
|
|
52
|
+
- **Timeout:** 300s
|
|
53
|
+
- **Retry:** up to 2 attempts
|
|
54
|
+
|
|
55
|
+
### Step 4 — Plan `[on_failure: STOP]`
|
|
56
|
+
- **Skill:** `speckit.plan`
|
|
57
|
+
- **Input:** reads from step 3 artifacts
|
|
58
|
+
- **Output:** `specs/*/plan.md`
|
|
59
|
+
- **Timeout:** 300s
|
|
60
|
+
- **Retry:** up to 2 attempts
|
|
61
|
+
|
|
62
|
+
### Step 5 — Tasks `[on_failure: STOP]`
|
|
63
|
+
- **Skill:** `speckit.tasks`
|
|
64
|
+
- **Input:** reads from step 4 artifacts
|
|
65
|
+
- **Output:** `specs/*/tasks.md`
|
|
66
|
+
- **Timeout:** 300s
|
|
67
|
+
- **Retry:** up to 2 attempts
|
|
68
|
+
|
|
69
|
+
### Step 6 — Analyze `[on_failure: CONTINUE]`
|
|
70
|
+
- **Skill:** `speckit.analyze`
|
|
71
|
+
- **Purpose:** Cross-artifact consistency check (spec ↔ plan ↔ tasks). Non-destructive — report only.
|
|
72
|
+
- **Timeout:** 300s
|
|
73
|
+
|
|
74
|
+
### Step 7 — Commit & Push `[on_failure: CONTINUE]`
|
|
75
|
+
- **Action:** Commit all files and push to remote if configured.
|
|
76
|
+
- **Timeout:** 120s
|
|
24
77
|
|
|
25
|
-
|
|
78
|
+
After all steps complete, return: the feature name, number of tasks created, and the path to tasks.md.
|
|
79
|
+
"""
|
|
26
80
|
|
|
27
|
-
|
|
81
|
+
---
|
|
28
82
|
|
|
29
|
-
|
|
83
|
+
## Phase 2: Implementation
|
|
30
84
|
|
|
31
|
-
|
|
85
|
+
> **Execution context:** Runs in main context after subagent completes.
|
|
32
86
|
|
|
33
|
-
|
|
34
|
-
|
|
87
|
+
### Step 8 — Compact `[on_failure: CONTINUE]`
|
|
88
|
+
- **Action:** Run `/compact` to free context window before implementation.
|
|
35
89
|
|
|
36
|
-
|
|
90
|
+
### Step 9 — Implement (loop) `[on_failure: CONTINUE | max_retries: 3]`
|
|
91
|
+
- **Engine:** ralph-loop
|
|
92
|
+
- **Completion promise:** `FINISHED`
|
|
93
|
+
- **Max iterations:** 10
|
|
94
|
+
- **Action:** Run:
|
|
37
95
|
|
|
38
|
-
|
|
96
|
+
`/ralph-loop:ralph-loop "systematically execute speckit.implement via the Skill tool to complete every task defined in specs/*/tasks.md with strict adherence to specification requirements, enforce TDD workflow including writing and passing unit, integration, and end-to-end tests before marking any task complete, ensure code quality through linting, static analysis, and consistent architecture with reusable components and centralized business logic, maintain atomic commits after each successful task with clear traceability, avoid requesting confirmation and proceed autonomously, once all tasks are implemented invoke speckit.analyze via the Skill tool to perform a full validation pass, automatically apply all recommended improvements or corrections, re-run all tests to confirm stability and zero regression, and only output <promise>FINISHED</promise> after every task is fully completed, validated, and aligned with production-grade quality standards" --completion-promise "FINISHED" --max-iterations 10`
|
|
39
97
|
|
|
40
|
-
|
|
98
|
+
---
|
|
41
99
|
|
|
42
|
-
|
|
100
|
+
## Chain Summary
|
|
101
|
+
|
|
102
|
+
```
|
|
103
|
+
Phase 1 (subagent) Phase 2 (main context)
|
|
104
|
+
───────────────────── ──────────────────────
|
|
105
|
+
Step 0: brainstorm ──STOP──┐ Step 8: compact
|
|
106
|
+
Step 1: constitution ─STOP─┤ Step 9: implement (ralph-loop)
|
|
107
|
+
Step 2: CLAUDE.md sync ────┤ Step 10: verify (via step 9)
|
|
108
|
+
Step 3: specify ──────STOP─┤
|
|
109
|
+
Step 4: plan ─────────STOP─┤
|
|
110
|
+
Step 5: tasks ────────STOP─┤
|
|
111
|
+
Step 6: analyze ───────────┤
|
|
112
|
+
Step 7: commit & push ─────┘
|
|
113
|
+
```
|