npm - @cregis-dev/cckit - Versions diffs - 0.4.0 → 0.5.0 - Mend

@cregis-dev/cckit 0.4.0 → 0.5.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.

Files changed (798) hide show

package/templates/bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-04-decisions.md DELETED Viewed

@@ -1,318 +0,0 @@
-# Step 4: Core Architectural Decisions
-## MANDATORY EXECUTION RULES (READ FIRST):
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on making critical architectural decisions collaboratively
-- 🌐 ALWAYS search the web to verify current technology versions
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-## EXECUTION PROTOCOLS:
-- 🎯 Show your analysis before taking any action
-- 🌐 Search the web to verify technology versions and options
-- ⚠️ Present A/P/C menu after each major decision category
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-## COLLABORATION MENUS (A/P/C):
-This step will generate content and present choices for each decision category:
-- **A (Advanced Elicitation)**: Use discovery protocols to explore innovative approaches to specific decisions
-- **P (Party Mode)**: Bring multiple perspectives to evaluate decision trade-offs
-- **C (Continue)**: Save the current decisions and proceed to next decision category
-## PROTOCOL INTEGRATION:
-- When 'A' selected: Read fully and follow: {project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml
-- When 'P' selected: Read fully and follow: {project-root}/_bmad/core/workflows/party-mode/workflow.md
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-## CONTEXT BOUNDARIES:
-- Project context from step 2 is available
-- Starter template choice from step 3 is available
-- Project context file may contain technical preferences and rules
-- Technical preferences discovered in step 3 are available
-- Focus on decisions not already made by starter template or existing preferences
-- Collaborative decision making, not recommendations
-## YOUR TASK:
-Facilitate collaborative architectural decision making, leveraging existing technical preferences and starter template decisions, focusing on remaining choices critical to the project's success.
-## DECISION MAKING SEQUENCE:
-### 1. Load Decision Framework & Check Existing Preferences
-**Review Technical Preferences from Step 3:**
-"Based on our technical preferences discussion in step 3, let's build on those foundations:
-**Your Technical Preferences:**
-{{user_technical_preferences_from_step_3}}
-**Starter Template Decisions:**
-{{starter_template_decisions}}
-**Project Context Technical Rules:**
-{{project_context_technical_rules}}"
-**Identify Remaining Decisions:**
-Based on technical preferences, starter template choice, and project context, identify remaining critical decisions:
-**Already Decided (Don't re-decide these):**
-- {{starter_template_decisions}}
-- {{user_technology_preferences}}
-- {{project_context_technical_rules}}
-**Critical Decisions:** Must be decided before implementation can proceed
-**Important Decisions:** Shape the architecture significantly
-**Nice-to-Have:** Can be deferred if needed
-### 2. Decision Categories by Priority
-#### Category 1: Data Architecture
-- Database choice (if not determined by starter)
-- Data modeling approach
-- Data validation strategy
-- Migration approach
-- Caching strategy
-#### Category 2: Authentication & Security
-- Authentication method
-- Authorization patterns
-- Security middleware
-- Data encryption approach
-- API security strategy
-#### Category 3: API & Communication
-- API design patterns (REST, GraphQL, etc.)
-- API documentation approach
-- Error handling standards
-- Rate limiting strategy
-- Communication between services
-#### Category 4: Frontend Architecture (if applicable)
-- State management approach
-- Component architecture
-- Routing strategy
-- Performance optimization
-- Bundle optimization
-#### Category 5: Infrastructure & Deployment
-- Hosting strategy
-- CI/CD pipeline approach
-- Environment configuration
-- Monitoring and logging
-- Scaling strategy
-### 3. Facilitate Each Decision Category
-For each category, facilitate collaborative decision making:
-**Present the Decision:**
-Based on user skill level and project context:
-**Expert Mode:**
-"{{Decision_Category}}: {{Specific_Decision}}
-Options: {{concise_option_list_with_tradeoffs}}
-What's your preference for this decision?"
-**Intermediate Mode:**
-"Next decision: {{Human_Friendly_Category}}
-We need to choose {{Specific_Decision}}.
-Common options:
-{{option_list_with_brief_explanations}}
-For your project, I'd lean toward {{recommendation}} because {{reason}}. What are your thoughts?"
-**Beginner Mode:**
-"Let's talk about {{Human_Friendly_Category}}.
-{{Educational_Context_About_Why_This_Matters}}
-Think of it like {{real_world_analogy}}.
-Your main options:
-{{friendly_options_with_pros_cons}}
-My suggestion: {{recommendation}}
-This is good for you because {{beginner_friendly_reason}}.
-What feels right to you?"
-**Verify Technology Versions:**
-If decision involves specific technology:
-```
-Search the web: "{{technology}} latest stable version"
-Search the web: "{{technology}} current LTS version"
-Search the web: "{{technology}} production readiness"
-```
-**Get User Input:**
-"What's your preference? (or 'explain more' for details)"
-**Handle User Response:**
-- If user wants more info: Provide deeper explanation
-- If user has preference: Discuss implications and record decision
-- If user wants alternatives: Explore other options
-**Record the Decision:**
-- Category: {{category}}
-- Decision: {{user_choice}}
-- Version: {{verified_version_if_applicable}}
-- Rationale: {{user_reasoning_or_default}}
-- Affects: {{components_or_epics}}
-- Provided by Starter: {{yes_if_from_starter}}
-### 4. Check for Cascading Implications
-After each major decision, identify related decisions:
-"This choice means we'll also need to decide:
-- {{related_decision_1}}
-- {{related_decision_2}}"
-### 5. Generate Decisions Content
-After facilitating all decision categories, prepare the content to append:
-#### Content Structure:
-```markdown
-## Core Architectural Decisions
-### Decision Priority Analysis
-**Critical Decisions (Block Implementation):**
-{{critical_decisions_made}}
-**Important Decisions (Shape Architecture):**
-{{important_decisions_made}}
-**Deferred Decisions (Post-MVP):**
-{{decisions_deferred_with_rationale}}
-### Data Architecture
-{{data_related_decisions_with_versions_and_rationale}}
-### Authentication & Security
-{{security_related_decisions_with_versions_and_rationale}}
-### API & Communication Patterns
-{{api_related_decisions_with_versions_and_rationale}}
-### Frontend Architecture
-{{frontend_related_decisions_with_versions_and_rationale}}
-### Infrastructure & Deployment
-{{infrastructure_related_decisions_with_versions_and_rationale}}
-### Decision Impact Analysis
-**Implementation Sequence:**
-{{ordered_list_of_decisions_for_implementation}}
-**Cross-Component Dependencies:**
-{{how_decisions_affect_each_other}}
-```
-### 6. Present Content and Menu
-Show the generated decisions content and present choices:
-"I've documented all the core architectural decisions we've made together.
-**Here's what I'll add to the document:**
-[Show the complete markdown content from step 5]
-**What would you like to do?**
-[A] Advanced Elicitation - Explore innovative approaches to any specific decisions
-[P] Party Mode - Review decisions from multiple perspectives
-[C] Continue - Save these decisions and move to implementation patterns"
-### 7. Handle Menu Selection
-#### If 'A' (Advanced Elicitation):
-- Read fully and follow: {project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml with specific decision categories
-- Process enhanced insights about particular decisions
-- Ask user: "Accept these enhancements to the architectural decisions? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-#### If 'P' (Party Mode):
-- Read fully and follow: {project-root}/_bmad/core/workflows/party-mode/workflow.md with architectural decisions context
-- Process collaborative insights about decision trade-offs
-- Ask user: "Accept these changes to the architectural decisions? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-#### If 'C' (Continue):
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4]`
-- Load `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-05-patterns.md`
-## APPEND TO DOCUMENT:
-When user selects 'C', append the content directly to the document using the structure from step 5.
-## SUCCESS METRICS:
-✅ All critical architectural decisions made collaboratively
-✅ Technology versions verified using web search
-✅ Decision rationale clearly documented
-✅ Cascading implications identified and addressed
-✅ User provided appropriate level of explanation for skill level
-✅ A/P/C menu presented and handled correctly for each category
-✅ Content properly appended to document when C selected
-## FAILURE MODES:
-❌ Making recommendations instead of facilitating decisions
-❌ Not verifying technology versions with web search
-❌ Missing cascading implications between decisions
-❌ Not adapting explanations to user skill level
-❌ Forgetting to document decisions made by starter template
-❌ Not presenting A/P/C menu after content generation
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-## NEXT STEP:
-After user selects 'C' and content is saved to document, load `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-05-patterns.md` to define implementation patterns that ensure consistency across AI agents.
-Remember: Do NOT proceed to step-05 until user explicitly selects 'C' from the A/P/C menu and content is saved!

package/templates/bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-05-patterns.md DELETED Viewed

@@ -1,359 +0,0 @@
-# Step 5: Implementation Patterns & Consistency Rules
-## MANDATORY EXECUTION RULES (READ FIRST):
-- 🛑 NEVER generate content without user input
-- 📖 CRITICAL: ALWAYS read the complete step file before taking any action - partial understanding leads to incomplete decisions
-- 🔄 CRITICAL: When loading next step with 'C', ensure the entire file is read and understood before proceeding
-- ✅ ALWAYS treat this as collaborative discovery between architectural peers
-- 📋 YOU ARE A FACILITATOR, not a content generator
-- 💬 FOCUS on patterns that prevent AI agent implementation conflicts
-- 🎯 EMPHASIZE what agents could decide DIFFERENTLY if not specified
-- ⚠️ ABSOLUTELY NO TIME ESTIMATES - AI development speed has fundamentally changed
-- ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config `{communication_language}`
-## EXECUTION PROTOCOLS:
-- 🎯 Show your analysis before taking any action
-- 🎯 Focus on consistency, not implementation details
-- ⚠️ Present A/P/C menu after generating patterns content
-- 💾 ONLY save when user chooses C (Continue)
-- 📖 Update frontmatter `stepsCompleted: [1, 2, 3, 4, 5]` before loading next step
-- 🚫 FORBIDDEN to load next step until C is selected
-## COLLABORATION MENUS (A/P/C):
-This step will generate content and present choices:
-- **A (Advanced Elicitation)**: Use discovery protocols to develop comprehensive consistency patterns
-- **P (Party Mode)**: Bring multiple perspectives to identify potential conflict points
-- **C (Continue)**: Save the patterns and proceed to project structure
-## PROTOCOL INTEGRATION:
-- When 'A' selected: Read fully and follow: {project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml
-- When 'P' selected: Read fully and follow: {project-root}/_bmad/core/workflows/party-mode/workflow.md
-- PROTOCOLS always return to display this step's A/P/C menu after the A or P have completed
-- User accepts/rejects protocol changes before proceeding
-## CONTEXT BOUNDARIES:
-- Core architectural decisions from step 4 are complete
-- Technology stack is decided and versions are verified
-- Focus on HOW agents should implement, not WHAT they should implement
-- Consider what could vary between different AI agents
-## YOUR TASK:
-Define implementation patterns and consistency rules that ensure multiple AI agents write compatible, consistent code that works together seamlessly.
-## PATTERNS DEFINITION SEQUENCE:
-### 1. Identify Potential Conflict Points
-Based on the chosen technology stack and decisions, identify where AI agents could make different choices:
-**Naming Conflicts:**
-- Database table/column naming conventions
-- API endpoint naming patterns
-- File and directory naming
-- Component/function/variable naming
-- Route parameter formats
-**Structural Conflicts:**
-- Where tests are located
-- How components are organized
-- Where utilities and helpers go
-- Configuration file organization
-- Static asset organization
-**Format Conflicts:**
-- API response wrapper formats
-- Error response structures
-- Date/time formats in APIs and UI
-- JSON field naming conventions
-- API status code usage
-**Communication Conflicts:**
-- Event naming conventions
-- Event payload structures
-- State update patterns
-- Action naming conventions
-- Logging formats and levels
-**Process Conflicts:**
-- Loading state handling
-- Error recovery patterns
-- Retry implementation approaches
-- Authentication flow patterns
-- Validation timing and methods
-### 2. Facilitate Pattern Decisions
-For each conflict category, facilitate collaborative pattern definition:
-**Present the Conflict Point:**
-"Given that we're using {{tech_stack}}, different AI agents might handle {{conflict_area}} differently.
-For example, one agent might name database tables 'users' while another uses 'Users' - this would cause conflicts.
-We need to establish consistent patterns that all agents follow."
-**Show Options and Trade-offs:**
-"Common approaches for {{pattern_category}}:
-1. {{option_1}} - {{pros_and_cons}}
-2. {{option_2}} - {{pros_and_cons}}
-3. {{option_3}} - {{pros_and_cons}}
-Which approach makes the most sense for our project?"
-**Get User Decision:**
-"What's your preference for this pattern? (or discuss the trade-offs more)"
-### 3. Define Pattern Categories
-#### Naming Patterns
-**Database Naming:**
-- Table naming: users, Users, or user?
-- Column naming: user_id or userId?
-- Foreign key format: user_id or fk_user?
-- Index naming: idx_users_email or users_email_index?
-**API Naming:**
-- REST endpoint naming: /users or /user? Plural or singular?
-- Route parameter format: :id or {id}?
-- Query parameter naming: user_id or userId?
-- Header naming conventions: X-Custom-Header or Custom-Header?
-**Code Naming:**
-- Component naming: UserCard or user-card?
-- File naming: UserCard.tsx or user-card.tsx?
-- Function naming: getUserData or get_user_data?
-- Variable naming: userId or user_id?
-#### Structure Patterns
-**Project Organization:**
-- Where do tests live? **tests**/ or \*.test.ts co-located?
-- How are components organized? By feature or by type?
-- Where do shared utilities go?
-- How are services and repositories organized?
-**File Structure:**
-- Config file locations and naming
-- Static asset organization
-- Documentation placement
-- Environment file organization
-#### Format Patterns
-**API Formats:**
-- API response wrapper? {data: ..., error: ...} or direct response?
-- Error format? {message, code} or {error: {type, detail}}?
-- Date format in JSON? ISO strings or timestamps?
-- Success response structure?
-**Data Formats:**
-- JSON field naming: snake_case or camelCase?
-- Boolean representations: true/false or 1/0?
-- Null handling patterns
-- Array vs object for single items
-#### Communication Patterns
-**Event Systems:**
-- Event naming convention: user.created or UserCreated?
-- Event payload structure standards
-- Event versioning approach
-- Async event handling patterns
-**State Management:**
-- State update patterns: immutable updates or direct mutation?
-- Action naming conventions
-- Selector patterns
-- State organization principles
-#### Process Patterns
-**Error Handling:**
-- Global error handling approach
-- Error boundary patterns
-- User-facing error message format
-- Logging vs user error distinction
-**Loading States:**
-- Loading state naming conventions
-- Global vs local loading states
-- Loading state persistence
-- Loading UI patterns
-### 4. Generate Patterns Content
-Prepare the content to append to the document:
-#### Content Structure:
-```markdown
-## Implementation Patterns & Consistency Rules
-### Pattern Categories Defined
-**Critical Conflict Points Identified:**
-{{number_of_potential_conflicts}} areas where AI agents could make different choices
-### Naming Patterns
-**Database Naming Conventions:**
-{{database_naming_rules_with_examples}}
-**API Naming Conventions:**
-{{api_naming_rules_with_examples}}
-**Code Naming Conventions:**
-{{code_naming_rules_with_examples}}
-### Structure Patterns
-**Project Organization:**
-{{project_structure_rules_with_examples}}
-**File Structure Patterns:**
-{{file_organization_rules_with_examples}}
-### Format Patterns
-**API Response Formats:**
-{{api_response_structure_rules}}
-**Data Exchange Formats:**
-{{data_format_rules_with_examples}}
-### Communication Patterns
-**Event System Patterns:**
-{{event_naming_and_structure_rules}}
-**State Management Patterns:**
-{{state_update_and_organization_rules}}
-### Process Patterns
-**Error Handling Patterns:**
-{{consistent_error_handling_approaches}}
-**Loading State Patterns:**
-{{loading_state_management_rules}}
-### Enforcement Guidelines
-**All AI Agents MUST:**
-- {{mandatory_pattern_1}}
-- {{mandatory_pattern_2}}
-- {{mandatory_pattern_3}}
-**Pattern Enforcement:**
-- How to verify patterns are followed
-- Where to document pattern violations
-- Process for updating patterns
-### Pattern Examples
-**Good Examples:**
-{{concrete_examples_of_correct_pattern_usage}}
-**Anti-Patterns:**
-{{examples_of_what_to_avoid}}
-```
-### 5. Present Content and Menu
-Show the generated patterns content and present choices:
-"I've documented implementation patterns that will prevent conflicts between AI agents working on this project.
-**Here's what I'll add to the document:**
-[Show the complete markdown content from step 4]
-**What would you like to do?**
-[A] Advanced Elicitation - Explore additional consistency patterns
-[P] Party Mode - Review patterns from different implementation perspectives
-[C] Continue - Save these patterns and move to project structure"
-### 6. Handle Menu Selection
-#### If 'A' (Advanced Elicitation):
-- Read fully and follow: {project-root}/_bmad/core/workflows/advanced-elicitation/workflow.xml with current patterns
-- Process enhanced consistency rules that come back
-- Ask user: "Accept these additional pattern refinements? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-#### If 'P' (Party Mode):
-- Read fully and follow: {project-root}/_bmad/core/workflows/party-mode/workflow.md with implementation patterns context
-- Process collaborative insights about potential conflicts
-- Ask user: "Accept these changes to the implementation patterns? (y/n)"
-- If yes: Update content, then return to A/P/C menu
-- If no: Keep original content, then return to A/P/C menu
-#### If 'C' (Continue):
-- Append the final content to `{planning_artifacts}/architecture.md`
-- Update frontmatter: `stepsCompleted: [1, 2, 3, 4, 5]`
-- Load `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-06-structure.md`
-## APPEND TO DOCUMENT:
-When user selects 'C', append the content directly to the document using the structure from step 4.
-## SUCCESS METRICS:
-✅ All potential AI agent conflict points identified and addressed
-✅ Comprehensive patterns defined for naming, structure, and communication
-✅ Concrete examples provided for each pattern
-✅ Enforcement guidelines clearly documented
-✅ User collaborated on pattern decisions rather than receiving recommendations
-✅ A/P/C menu presented and handled correctly
-✅ Content properly appended to document when C selected
-## FAILURE MODES:
-❌ Missing potential conflict points that could cause agent conflicts
-❌ Being too prescriptive about implementation details instead of focusing on consistency
-❌ Not providing concrete examples for each pattern
-❌ Failing to address cross-cutting concerns like error handling
-❌ Not considering the chosen technology stack when defining patterns
-❌ Not presenting A/P/C menu after content generation
-❌ **CRITICAL**: Reading only partial step file - leads to incomplete understanding and poor decisions
-❌ **CRITICAL**: Proceeding with 'C' without fully reading and understanding the next step file
-❌ **CRITICAL**: Making decisions without complete understanding of step requirements and protocols
-## NEXT STEP:
-After user selects 'C' and content is saved to document, load `{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/steps/step-06-structure.md` to define the complete project structure.
-Remember: Do NOT proceed to step-06 until user explicitly selects 'C' from the A/P/C menu and content is saved!