@pennyfarthing/core 10.1.0 → 10.2.0

package/pennyfarthing-dist/workflows/dev-story/workflow.yaml

@@ -1,50 +0,0 @@
-# BMAD Dev-Story Workflow - Imported for BMAD Compatibility
-#
-# This is a reference workflow imported from BMAD for compatibility with
-# BMAD-based projects. It is NOT a replacement for Pennyfarthing's native
-# TDD workflow (tdd.yaml).
-#
-# Key differences from Pennyfarthing TDD:
-# - Single-agent execution (Dev only)
-# - XML-based procedural instructions (10 steps)
-# - Integrated test writing within implementation flow
-# - Updates BMAD sprint-status.yaml format
-#
-# For Pennyfarthing projects, use tdd.yaml which provides:
-# - Multi-agent orchestration (SM, TEA, Dev, Reviewer)
-# - Phase-based workflow with handoffs
-# - Session file state tracking
-#
-# Source: BMAD-METHOD/src/modules/bmm/workflows/4-implementation/dev-story/
-# Migrated: 2026-01-21
-
-workflow:
-  name: dev-story
-  description: |
-    BMAD reference workflow: Execute a story by implementing tasks/subtasks,
-    writing tests, validating, and updating the story file per acceptance criteria.
-    This is imported for BMAD compatibility - use tdd.yaml for Pennyfarthing projects.
-  version: "1.0.0"
-  type: procedural
-  author: BMad
-
-  # Primary agent for this workflow
-  agent: dev
-
-  # Instructions and validation files
-  instructions: ./instructions.xml
-  checklist: ./checklist.md
-
-  # Variables available in instruction files
-  variables:
-    project_root: .
-    story_dir: ./artifacts/stories
-    implementation_artifacts: ./artifacts
-    sprint_status: ./artifacts/sprint-status.yaml
-    project_context: "**/project-context.md"
-
-  # Triggers - when to suggest this workflow
-  triggers:
-    types: [bmad-story, bmad-dev]
-    tags: [bmad, reference, procedural]
-    # NOT default - TDD is the default for Pennyfarthing

package/pennyfarthing-dist/workflows/quick-spec/steps/step-01-understand.md

@@ -1,201 +0,0 @@
----
-name: 'step-01-understand'
-description: 'Analyze the requirement delta between current state and what user wants to build'
-
-workflow_path: '{project_root}/_bmad/bmm/workflows/bmad-quick-flow/create-tech-spec'
-nextStepFile: './step-02-investigate.md'
-skipToStepFile: './step-03-generate.md'
-templateFile: '{workflow_path}/tech-spec-template.md'
-wipFile: '{implementation_artifacts}/tech-spec-wip.md'
----
-
-<purpose>
-Analyze the requirement delta between the current state and what the user wants to build. Establish a verifiable delta between current and target state by eliciting requirements, performing surface-level code scans, and initializing a work-in-progress technical specification document.
-</purpose>
-
-<instructions>
-Execute the sequence of instructions in order: Check for existing WIP (with recovery menu), greet user and gather initial request, perform quick orient scan, ask informed questions based on findings, capture core understanding with user confirmation, initialize WIP file with template and metadata, and present checkpoint menu for next steps (Advanced Elicitation, Continue, or Party Mode).
-</instructions>
-
-<output>
-WIP file initialized at {wipFile} with captured metadata (title, slug, created date, status, stepsCompleted: [1]), Overview section with Problem Statement/Solution/Scope, and Context for Development section. User selected to continue to next step.
-</output>
-
-# Step 1: Analyze Requirement Delta
-
-**Progress: Step 1 of 4** - Next: Deep Investigation
-
-## RULES:
-
-- MUST NOT skip steps.
-- MUST NOT optimize sequence.
-- MUST follow exact instructions.
-- MUST NOT look ahead to future steps.
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## CONTEXT:
-
-- Variables from `workflow.md` are available in memory.
-- Focus: Define the technical requirement delta and scope.
-- Investigation: Perform surface-level code scans ONLY to verify the delta. Reserve deep dives into implementation consequences for Step 2.
-- Objective: Establish a verifiable delta between current state and target state.
-
-## SEQUENCE OF INSTRUCTIONS
-
-### 0. Check for Work in Progress
-
-a) **Before anything else, check if `{wipFile}` exists:**
-
-b) **IF WIP FILE EXISTS:**
-
-1. Read the frontmatter and extract: `title`, `slug`, `stepsCompleted`
-2. Calculate progress: `lastStep = max(stepsCompleted)`
-3. Present to user:
-
-```
-Hey {user_name}! Found a tech-spec in progress:
-
-**{title}** - Step {lastStep} of 4 complete
-
-Is this what you're here to continue?
-
-[y] Yes, pick up where I left off
-[n] No, archive it and start something new
-```
-
-4. **HALT and wait for user selection.**
-
-a) **Menu Handling:**
-
-- **[y] Continue existing:**
-  - Jump directly to the appropriate step based on `stepsCompleted`:
-    - `[1]` → Load `{nextStepFile}` (Step 2)
-    - `[1, 2]` → Load `{skipToStepFile}` (Step 3)
-    - `[1, 2, 3]` → Load `./step-04-review.md` (Step 4)
-- **[n] Archive and start fresh:**
-  - Rename `{wipFile}` to `{implementation_artifacts}/tech-spec-{slug}-archived-{date}.md`
-
-### 1. Greet and Ask for Initial Request
-
-a) **Greet the user briefly:**
-
-"Hey {user_name}! What are we building today?"
-
-b) **Get their initial description.** Don't ask detailed questions yet - just understand enough to know where to look.
-
-### 2. Quick Orient Scan
-
-a) **Before asking detailed questions, do a rapid scan to understand the landscape:**
-
-b) **Check for existing context docs:**
-
-- Check `{output_folder}` and `{planning_artifacts}`for planning documents (PRD, architecture, epics, research)
-- Check for `**/project-context.md` - if it exists, skim for patterns and conventions
-- Check for any existing stories or specs related to user's request
-
-c) **If user mentioned specific code/features, do a quick scan:**
-
-- Search for relevant files/classes/functions they mentioned
-- Skim the structure (don't deep-dive yet - that's Step 2)
-- Note: tech stack, obvious patterns, file locations
-
-d) **Build mental model:**
-
-- What's the likely landscape for this feature?
-- What's the likely scope based on what you found?
-- What questions do you NOW have, informed by the code?
-
-**This scan should take < 30 seconds. Just enough to ask smart questions.**
-
-### 3. Ask Informed Questions
-
-a) **Now ask clarifying questions - but make them INFORMED by what you found:**
-
-Instead of generic questions like "What's the scope?", ask specific ones like:
-- "`AuthService` handles validation in the controller — should the new field follow that pattern or move it to a dedicated validator?"
-- "`NavigationSidebar` component uses local state for the 'collapsed' toggle — should we stick with that or move it to the global store?"
-- "The epics doc mentions X - is this related?"
-
-**Adapt to {user_skill_level}.** Technical users want technical questions. Non-technical users need translation.
-
-b) **If no existing code is found:**
-
-- Ask about intended architecture, patterns, constraints
-- Ask what similar systems they'd like to emulate
-
-### 4. Capture Core Understanding
-
-a) **From the conversation, extract and confirm:**
-
-- **Title**: A clear, concise name for this work
-- **Slug**: URL-safe version of title (lowercase, hyphens, no spaces)
-- **Problem Statement**: What problem are we solving?
-- **Solution**: High-level approach (1-2 sentences)
-- **In Scope**: What's included
-- **Out of Scope**: What's explicitly NOT included
-
-b) **Ask the user to confirm the captured understanding before proceeding.**
-
-### 5. Initialize WIP File
-
-a) **Create the tech-spec WIP file:**
-
-1. Copy template from `{templateFile}`
-2. Write to `{wipFile}`
-3. Update frontmatter with captured values:
-   ```yaml
-   ---
-   title: '{title}'
-   slug: '{slug}'
-   created: '{date}'
-   status: 'in-progress'
-   stepsCompleted: [1]
-   tech_stack: []
-   files_to_modify: []
-   code_patterns: []
-   test_patterns: []
-   ---
-   ```
-4. Fill in Overview section with Problem Statement, Solution, and Scope
-5. Fill in Context for Development section with any technical preferences or constraints gathered during informed discovery.
-6. Write the file
-
-b) **Report to user:**
-
-"Created: `{wipFile}`
-
-**Captured:**
-
-- Title: {title}
-- Problem: {problem_statement_summary}
-- Scope: {scope_summary}"
-
-### 6. Present Checkpoint Menu
-
-a) **Display menu:**
-
-```
-[a] Advanced Elicitation - dig deeper into requirements
-[c] Continue - proceed to next step
-[p] Party Mode - bring in other experts
-```
-
-b) **HALT and wait for user selection.**
-
-#### Menu Handling:
-
-- **[a]**: Load and execute `{advanced_elicitation}`, then return here and redisplay menu
-- **[c]**: Load and execute `{nextStepFile}` (Map Technical Constraints)
-- **[p]**: Load and execute `{party_mode_exec}`, then return here and redisplay menu
-
----
-
-## REQUIRED OUTPUTS:
-
-- MUST initialize WIP file with captured metadata.
-
-## VERIFICATION CHECKLIST:
-
-- [ ] WIP check performed FIRST before any greeting.
-- [ ] `{wipFile}` created with correct frontmatter, Overview, Context for Development, and `stepsCompleted: [1]`.
-- [ ] User selected [c] to continue.

package/pennyfarthing-dist/workflows/quick-spec/steps/step-02-investigate.md

@@ -1,156 +0,0 @@
----
-name: 'step-02-investigate'
-description: 'Map technical constraints and anchor points within the codebase'
-
-workflow_path: '{project_root}/_bmad/bmm/workflows/bmad-quick-flow/create-tech-spec'
-nextStepFile: './step-03-generate.md'
-wipFile: '{implementation_artifacts}/tech-spec-wip.md'
----
-
-<purpose>
-Map technical constraints and anchor points within the codebase to provide implementation-ready ground truth. Build on the Quick Scan from Step 1 with deep investigation to identify exact files to modify, code patterns to follow, and technical constraints that will impact implementation.
-</purpose>
-
-<instructions>
-Load the WIP file from Step 1, execute universal code investigation by reading and analyzing relevant files/directories, document technical context (tech stack, code patterns, files to modify, test patterns), look for project-context.md if not already loaded, update WIP file frontmatter and Context for Development section, and present checkpoint menu for Advanced Elicitation, Continue, or Party Mode.
-</instructions>
-
-<output>
-WIP file updated with documented technical context including tech_stack, files_to_modify, code_patterns, and test_patterns in frontmatter. Context for Development section filled with Codebase Patterns, Files to Reference table, and Technical Decisions. User confirmed with [c] to continue to Step 3.
-</output>
-
-# Step 2: Map Technical Constraints & Anchor Points
-
-**Progress: Step 2 of 4** - Next: Generate Plan
-
-## RULES:
-
-- MUST NOT skip steps.
-- MUST NOT optimize sequence.
-- MUST follow exact instructions.
-- MUST NOT generate the full spec yet (that's Step 3).
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## CONTEXT:
-
-- Requires `{wipFile}` from Step 1 with the "Problem Statement" defined.
-- Focus: Map the problem statement to specific anchor points in the codebase.
-- Output: Exact files to touch, classes/patterns to extend, and technical constraints identified.
-- Objective: Provide the implementation-ready ground truth for the plan.
-
-## SEQUENCE OF INSTRUCTIONS
-
-### 1. Load Current State
-
-**Read `{wipFile}` and extract:**
-
-- Problem statement and scope from Overview section
-- Any context gathered in Step 1
-
-### 2. Execute Investigation Path
-
-**Universal Code Investigation:**
-
-_Isolate deep exploration in sub-agents/tasks where available. Return distilled summaries only to prevent context snowballing._
-
-a) **Build on Step 1's Quick Scan**
-
-Review what was found in Step 1's orient scan. Then ask:
-
-"Based on my quick look, I see [files/patterns found]. Are there other files or directories I should investigate deeply?"
-
-b) **Read and Analyze Code**
-
-For each file/directory provided:
-
-- Read the complete file(s)
-- Identify patterns, conventions, coding style
-- Note dependencies and imports
-- Find related test files
-
-**If NO relevant code is found (Clean Slate):**
-
-- Identify the target directory where the feature should live.
-- Scan parent directories for architectural context.
-- Identify standard project utilities or boilerplate that SHOULD be used.
-- Document this as "Confirmed Clean Slate" - establishing that no legacy constraints exist.
-
-
-c) **Document Technical Context**
-
-Capture and confirm with user:
-
-- **Tech Stack**: Languages, frameworks, libraries
-- **Code Patterns**: Architecture patterns, naming conventions, file structure
-- **Files to Modify/Create**: Specific files that will need changes or new files to be created
-- **Test Patterns**: How tests are structured, test frameworks used
-
-d) **Look for project-context.md**
-
-If `**/project-context.md` exists and wasn't loaded in Step 1:
-
-- Load it now
-- Extract patterns and conventions
-- Note any rules that must be followed
-
-### 3. Update WIP File
-
-**Update `{wipFile}` frontmatter:**
-
-```yaml
----
-# ... existing frontmatter ...
-stepsCompleted: [1, 2]
-tech_stack: ['{captured_tech_stack}']
-files_to_modify: ['{captured_files}']
-code_patterns: ['{captured_patterns}']
-test_patterns: ['{captured_test_patterns}']
----
-```
-
-**Update the Context for Development section:**
-
-Fill in:
-
-- Codebase Patterns (from investigation)
-- Files to Reference table (files reviewed)
-- Technical Decisions (any decisions made during investigation)
-
-**Report to user:**
-
-"**Context Gathered:**
-
-- Tech Stack: {tech_stack_summary}
-- Files to Modify: {files_count} files identified
-- Patterns: {patterns_summary}
-- Tests: {test_patterns_summary}"
-
-### 4. Present Checkpoint Menu
-
-**Display menu:**
-
-```
-[a] Advanced Elicitation - explore more context
-[c] Continue - proceed to Generate Spec
-[p] Party Mode - bring in other experts
-```
-
-**HALT and wait for user selection.**
-
-#### Menu Handling:
-
-- **[a]**: Load and execute `{advanced_elicitation}`, then return here and redisplay menu
-- **[c]**: Verify frontmatter updated with `stepsCompleted: [1, 2]`, then load and execute `{nextStepFile}`
-- **[p]**: Load and execute `{party_mode_exec}`, then return here and redisplay menu
-
----
-
-## REQUIRED OUTPUTS:
-
-- MUST document technical context (stack, patterns, files identified).
-- MUST update `{wipFile}` with functional context.
-
-## VERIFICATION CHECKLIST:
-
-- [ ] Technical mapping performed and documented.
-- [ ] `stepsCompleted: [1, 2]` set in frontmatter.

package/pennyfarthing-dist/workflows/quick-spec/steps/step-03-generate.md

@@ -1,140 +0,0 @@
----
-name: 'step-03-generate'
-description: 'Build the implementation plan based on the technical mapping of constraints'
-
-workflow_path: '{project_root}/_bmad/bmm/workflows/bmad-quick-flow/create-tech-spec'
-nextStepFile: './step-04-review.md'
-wipFile: '{implementation_artifacts}/tech-spec-wip.md'
----
-
-<purpose>
-Generate an implementation-ready plan that addresses the requirement delta using the technical context captured in Steps 1 and 2. Create specific, ordered, actionable implementation tasks and testable acceptance criteria that meet the READY FOR DEVELOPMENT standard.
-</purpose>
-
-<instructions>
-Load the WIP file with all captured context, generate discrete implementation tasks with specific files and actions ordered logically, create testable acceptance criteria in Given/When/Then format covering happy path and edge cases, fill in Dependencies/Testing Strategy/Notes sections, update WIP frontmatter with stepsCompleted: [1, 2, 3] and status: 'review', and proceed to Step 4.
-</instructions>
-
-<output>
-WIP file updated with implementation plan including specific ordered tasks with file paths, testable acceptance criteria in Given/When/Then format, Dependencies documented, Testing Strategy defined, and Notes section completed. Frontmatter updated with stepsCompleted: [1, 2, 3] and status: 'review'. File ready for Step 4 review.
-</output>
-
-# Step 3: Generate Implementation Plan
-
-**Progress: Step 3 of 4** - Next: Review & Finalize
-
-## RULES:
-
-- MUST NOT skip steps.
-- MUST NOT optimize sequence.
-- MUST follow exact instructions.
-- MUST NOT implement anything - just document.
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-
-## CONTEXT:
-
-- Requires `{wipFile}` with defined "Overview" and "Context for Development" sections.
-- Focus: Create the implementation sequence that addresses the requirement delta using the captured technical context.
-- Output: Implementation-ready tasks with specific files and instructions.
-- Target: Meet the **READY FOR DEVELOPMENT** standard defined in `workflow.md`.
-
-## SEQUENCE OF INSTRUCTIONS
-
-### 1. Load Current State
-
-**Read `{wipFile}` completely and extract:**
-
-- All frontmatter values
-- Overview section (Problem, Solution, Scope)
-- Context for Development section (Patterns, Files, Decisions)
-
-### 2. Generate Implementation Plan
-
-Generate specific implementation tasks:
-
-a) **Task Breakdown**
-
-- Each task should be a discrete, completable unit of work
-- Tasks should be ordered logically (dependencies first)
-- Include the specific files to modify in each task
-- Be explicit about what changes to make
-
-b) **Task Format**
-
-```markdown
-- [ ] Task N: Clear action description
-  - File: `path/to/file.ext`
-  - Action: Specific change to make
-  - Notes: Any implementation details
-```
-
-### 3. Generate Acceptance Criteria
-
-**Create testable acceptance criteria:**
-
-Each AC should follow Given/When/Then format:
-
-```markdown
-- [ ] AC N: Given [precondition], when [action], then [expected result]
-```
-
-**Ensure ACs cover:**
-
-- Happy path functionality
-- Error handling
-- Edge cases (if relevant)
-- Integration points (if relevant)
-
-### 4. Complete Additional Context
-
-**Fill in remaining sections:**
-
-a) **Dependencies**
-
-- External libraries or services needed
-- Other tasks or features this depends on
-- API or data dependencies
-
-b) **Testing Strategy**
-
-- Unit tests needed
-- Integration tests needed
-- Manual testing steps
-
-c) **Notes**
-
-- High-risk items from pre-mortem analysis
-- Known limitations
-- Future considerations (out of scope but worth noting)
-
-### 5. Write Complete Spec
-
-a) **Update `{wipFile}` with all generated content:**
-
-- Ensure all template sections are filled in
-- No placeholder text remaining
-- All frontmatter values current
-- Update status to 'review' (NOT 'ready-for-dev' - that happens after user review in Step 4)
-
-b) **Update frontmatter:**
-
-```yaml
----
-# ... existing values ...
-status: 'review'
-stepsCompleted: [1, 2, 3]
----
-```
-
-c) **Load and execute `{nextStepFile}` (Step 4)**
-
-## REQUIRED OUTPUTS:
-
-- Tasks MUST be specific, actionable, ordered logically, with files to modify.
-- ACs MUST be testable, using Given/When/Then format.
-- Status MUST be updated to 'review'.
-
-## VERIFICATION CHECKLIST:
-
-- [ ] `stepsCompleted: [1, 2, 3]` set in frontmatter.
-- [ ] Spec meets the **READY FOR DEVELOPMENT** standard.