bms-speckit-plugin 2.1.1 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bms-speckit-plugin",
-  "version": "2.1.1",
+  "version": "3.0.0",
   "description": "Single-command automated development pipeline: /bms-speckit takes requirements and runs constitution → specify → plan → tasks → analyze → implement → verify",
   "files": [
     ".claude-plugin/",

package/skills/analyze/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: analyze
+description: Review tasks and implementation for quality and constitution compliance
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent
+---
+
+# Speckit Analyze
+
+Review tasks and/or implementation for quality and compliance.
+
+## Instructions
+
+1. Read `specs/constitution.md` for governing principles.
+
+2. Find and read the most recent `specs/*/tasks.md`.
+
+3. If tasks are pending — review task quality:
+   - Granular enough? (5-15 min each)
+   - Each independently testable?
+   - Dependencies correct?
+   - Every task has test-first step?
+   - Acceptance criteria clear?
+
+4. If tasks are completed — review implementation:
+   - Read the code written for completed tasks
+   - Check tests exist and are meaningful
+   - Check for code duplication
+   - Check error handling and UX feedback
+
+5. Fix any issues found in tasks.md. Add new tasks if needed.
+
+6. Commit if changes made.

package/skills/constitution/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: constitution
+description: Establish engineering principles that govern all speckit development work
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Speckit Constitution
+
+Establish the engineering constitution for this project.
+
+## Instructions
+
+1. Read the constitution text from the conversation context. If none provided, use the default principles below.
+
+2. Create `specs/` directory if it doesn't exist.
+
+3. Write `specs/constitution.md` with:
+
+```markdown
+# Engineering Constitution
+
+Established: {current date}
+
+## Principles
+
+{constitution text, formatted as numbered principles}
+
+## Enforcement
+
+All speckit commands must comply with these principles.
+```
+
+4. Check if CLAUDE.md exists. If it does, verify it aligns with the constitution and update if needed.
+
+5. Commit: `feat: establish engineering constitution`
+
+## Default Principles
+
+1. Code Quality — No hardcoded conditions, strict TypeScript, no shortcuts
+2. TDD — Always write tests FIRST, confirm failure, then implement
+3. Testing — Unit, component, integration, and API tests as appropriate
+4. UX — Consistent, professional, user-friendly interfaces with clear feedback
+5. Performance — Efficient architecture and resource management
+6. Version Control — Commit after every meaningful change with descriptive messages
+7. Reusability — Modular components, centralized business logic, no duplication
+8. User Feedback — Informative progress reporting and error messages
+9. Tool Leverage — Use all available skills, MCP tools, frameworks, and domain expertise

package/skills/implement/SKILL.md

@@ -0,0 +1,27 @@
+---
+name: implement
+description: Execute the next pending task from tasks.md using TDD
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent, WebSearch, WebFetch
+---
+
+# Speckit Implement
+
+Execute the next pending task using TDD.
+
+## Instructions
+
+1. Find `specs/*/tasks.md`. Find the first task with status `pending`.
+
+2. Update its status to `in_progress`.
+
+3. Execute TDD cycle:
+   a. Write the test first
+   b. Run tests — verify they FAIL
+   c. Write minimal implementation to pass
+   d. Run ALL tests — verify they PASS
+   e. Commit with the task's commit message
+
+4. Update task status to `completed`.
+
+5. Report: task name, tests passing, files changed, next pending task (or "all done").

package/skills/plan/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: plan
+description: Create an implementation plan from the most recent specification
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Speckit Plan
+
+Create a detailed implementation plan from the most recent specification.
+
+## Instructions
+
+1. Read `specs/constitution.md` for governing principles.
+
+2. Find and read the most recent `specs/*/specification.md`.
+
+3. Create `specs/{feature-name}/plan.md` containing:
+   - Architecture overview and file structure
+   - Implementation phases: Foundation → Core → UI → Integration → Testing
+   - Technology stack with justification
+   - Testing strategy (what to test, coverage targets)
+   - Risk assessment
+
+4. Commit: `feat: add implementation plan for {feature-name}`

package/skills/specify/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: specify
+description: Create a detailed specification from user requirements
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Agent, WebSearch, WebFetch
+---
+
+# Speckit Specify
+
+Create a detailed technical specification from the requirement provided in conversation context.
+
+## Instructions
+
+1. Read `specs/constitution.md` for governing principles.
+
+2. Read the requirement from conversation context.
+
+3. If database access is needed and MCP tools are available (list_tables, describe_table, query), explore the actual database schema.
+
+4. Create a feature directory name from the requirements (kebab-case).
+
+5. Write `specs/{feature-name}/specification.md` containing:
+   - Overview and user requirements
+   - Functional requirements (numbered, testable)
+   - Non-functional requirements (performance, security, UX)
+   - Technical analysis (database schema, API dependencies)
+   - Architecture (components, data flow)
+   - UI/UX design (screens, navigation, interactions)
+   - Data model (tables, relationships, queries)
+   - Constraints and success criteria
+
+6. Commit: `feat: add specification for {feature-name}`

package/skills/speckit/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: bms-speckit
+name: speckit
 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.
 argument-hint: <your requirement description>
 disable-model-invocation: true
@@ -8,117 +8,51 @@ allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Skill, Agent, WebSearch, Web
 
 # BMS Speckit — Automated Development Pipeline
 
-Takes a single requirement and runs the complete engineering workflow automatically:
-**constitution → specify → plan → tasks → analyze → implement → verify**
-
-## Engineering Constitution
-
-All work follows these principles:
-
-1. **Code Quality** — No hardcoded conditions, strict TypeScript, no shortcuts
-2. **TDD** — Always write tests FIRST, confirm failure, then implement
-3. **Testing** — Unit, component, integration, and API tests as appropriate
-4. **UX** — Consistent, professional, user-friendly interfaces with clear feedback
-5. **Performance** — Efficient architecture and resource management
-6. **Version Control** — Commit after every meaningful change with descriptive messages
-7. **Reusability** — Modular components, centralized business logic, no duplication
-8. **User Feedback** — Informative progress reporting and error messages
-9. **Tool Leverage** — Use all available skills, MCP tools, frameworks, and domain expertise
-
-## Workflow — Execute ALL steps in order, do NOT ask for confirmation
-
-### Step 1: Setup Constitution
-- Create `specs/` directory
-- Write `specs/constitution.md` with the principles above
-- Check CLAUDE.md compliance — update if needed
-- Commit: `feat: establish engineering constitution`
-
-### Step 2: Create Specification
-- The user's requirement is provided as the command argument: $ARGUMENTS
-- Analyze this requirement thoroughly
-- If database access is needed and MCP tools are available (list_tables, describe_table, query), explore the actual database schema
-- Create `specs/{feature-name}/specification.md` containing:
-  - Overview and user requirements
-  - Functional requirements (numbered, testable)
-  - Non-functional requirements (performance, security, UX)
-  - Technical analysis (database schema, API dependencies)
-  - Architecture (components, data flow)
-  - UI/UX design (screens, navigation, interactions)
-  - Data model (tables, relationships, queries)
-  - Constraints and success criteria
-- Commit: `feat: add specification for {feature-name}`
-
-### Step 3: Create Implementation Plan
-- Read the specification
-- Create `specs/{feature-name}/plan.md` containing:
-  - Architecture overview and file structure
-  - Implementation phases: Foundation → Core → UI → Integration → Testing
-  - Technology stack with justification
-  - Testing strategy (what to test, coverage targets)
-  - Risk assessment
-- Commit: `feat: add implementation plan for {feature-name}`
-
-### Step 4: Compact context (first)
-- Run `/compact` to free up context window after the heavy specification and planning work
-
-### Step 5: Create Task List
-- Read the plan
-- Create `specs/{feature-name}/tasks.md` with granular tasks (5-15 min each)
-- Each task includes:
+Takes a single requirement and runs the complete engineering workflow automatically by calling sub-skills in sequence. Do NOT ask for confirmation between steps.
 
-```
-### Task N: {Name}
-- **Status**: pending
-- **Priority**: high | medium | low
-- **Phase**: N
-- **Files**: exact file paths
-- **Description**: specific and actionable
-- **Tests**: what tests to write first
-- **Acceptance**: measurable verification criteria
-- **Commit message**: descriptive message
-```
+## Step 1: Constitution
+Invoke skill `bms-speckit:constitution` with the following constitution text:
+
+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.
+
+## Step 2: Specify
+Invoke skill `bms-speckit:specify` with this requirement: $ARGUMENTS
+
+## Step 3: Plan
+Invoke skill `bms-speckit:plan`
+
+## Step 4: Compact
+Run `/compact` to free context window after heavy specification and planning work.
 
-- Order: setup → data layer → business logic → UI → integration → polish
-- Commit: `feat: add task list for {feature-name}`
+## Step 5: Tasks
+Invoke skill `bms-speckit:tasks`
 
-### Step 6: Analyze Tasks
-- Review all tasks for quality:
-  - Granular enough? (5-15 min each)
-  - Each independently testable?
-  - Dependencies correct and explicit?
-  - Every task has test-first step?
-  - Acceptance criteria clear and measurable?
-- Fix any issues found in tasks.md
-- Commit if changes made
+## Step 6: Analyze
+Invoke skill `bms-speckit:analyze`
 
-### Step 7: Commit and push
-- Commit all spec files created so far
-- Push to remote if configured
-- This preserves work before the long implementation phase
+## Step 7: Commit and push
+Commit all spec files and push to remote if configured.
 
-### Step 8: Compact context (second)
-- Run `/compact` to free up context window before implementation
+## Step 8: Compact
+Run `/compact` to free context window before implementation.
 
-### Step 9: Implement with ralph-loop
+## Step 9: Implement with ralph-loop
 Invoke ralph-loop to implement all tasks automatically:
 
 ```
-/ralph-loop:ralph-loop "Read specs/*/tasks.md and implement the next pending task using TDD (write test first, verify fail, implement, verify pass, commit). Update task status to completed after each task. Do not ask for any confirmation. Once all tasks are done, run analysis: read specs/*/tasks.md and verify all tasks are completed, run the full test suite, check all specification requirements are met, fix any issues found, and output <promise>FINISHED</promise> only after all tasks are completed and revalidated" --completion-promise "FINISHED" --max-iterations 10
+/ralph-loop:ralph-loop "Invoke skill bms-speckit:implement to execute the next pending task. Repeat until all tasks in specs/*/tasks.md are finished. Do not ask for any confirmation. Once all tasks are done, invoke skill bms-speckit:analyze to recheck and update tasks, accept any recommendations, and output <promise>FINISHED</promise> only after all tasks are completed and revalidated" --completion-promise "FINISHED" --max-iterations 10
 ```
 
-### After ralph-loop completes
+## After ralph-loop completes
 
 Output a final summary:
 - What was built
 - Total tests passing
 - Files created/modified
 - How to run the application
-- Any remaining issues or recommendations
 
 ## CRITICAL RULES
-- Do NOT ask for confirmation between steps — run everything automatically
-- Do NOT skip the TDD cycle — test first, always
-- Commit after EVERY completed task
+- Do NOT ask for confirmation between steps
+- Each step invokes its sub-skill — do not implement inline
 - Use MCP tools if available (bms-session for database access)
-- If blocked on a task, skip it and continue — come back later
 - Push code if git remote is configured

package/skills/tasks/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: tasks
+description: Break an implementation plan into executable tasks with status tracking
+user-invocable: false
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep
+---
+
+# Speckit Tasks
+
+Break the implementation plan into granular, executable tasks.
+
+## Instructions
+
+1. Read `specs/constitution.md` for governing principles.
+
+2. Find and read the most recent `specs/*/plan.md`.
+
+3. Create `specs/{feature-name}/tasks.md` with granular tasks (5-15 min each):
+
+```
+### Task N: {Name}
+- **Status**: pending
+- **Priority**: high | medium | low
+- **Phase**: N
+- **Files**: exact file paths
+- **Description**: specific and actionable
+- **Tests**: what tests to write first
+- **Acceptance**: measurable verification criteria
+- **Commit message**: descriptive message
+```
+
+4. Order: setup → data layer → business logic → UI → integration → polish
+
+5. Commit: `feat: add task list for {feature-name}`