siesa-agents 1.0.0

package/bmad-core/data/brainstorming-techniques.md

@@ -0,0 +1,38 @@
+<!-- Powered by BMAD™ Core -->
+
+# Brainstorming Techniques Data
+
+## Creative Expansion
+
+1. **What If Scenarios**: Ask one provocative question, get their response, then ask another
+2. **Analogical Thinking**: Give one example analogy, ask them to find 2-3 more
+3. **Reversal/Inversion**: Pose the reverse question, let them work through it
+4. **First Principles Thinking**: Ask "What are the fundamentals?" and guide them to break it down
+
+## Structured Frameworks
+
+5. **SCAMPER Method**: Go through one letter at a time, wait for their ideas before moving to next
+6. **Six Thinking Hats**: Present one hat, ask for their thoughts, then move to next hat
+7. **Mind Mapping**: Start with central concept, ask them to suggest branches
+
+## Collaborative Techniques
+
+8. **"Yes, And..." Building**: They give idea, you "yes and" it, they "yes and" back - alternate
+9. **Brainwriting/Round Robin**: They suggest idea, you build on it, ask them to build on yours
+10. **Random Stimulation**: Give one random prompt/word, ask them to make connections
+
+## Deep Exploration
+
+11. **Five Whys**: Ask "why" and wait for their answer before asking next "why"
+12. **Morphological Analysis**: Ask them to list parameters first, then explore combinations together
+13. **Provocation Technique (PO)**: Give one provocative statement, ask them to extract useful ideas
+
+## Advanced Techniques
+
+14. **Forced Relationships**: Connect two unrelated concepts and ask them to find the bridge
+15. **Assumption Reversal**: Challenge their core assumptions and ask them to build from there
+16. **Role Playing**: Ask them to brainstorm from different stakeholder perspectives
+17. **Time Shifting**: "How would you solve this in 1995? 2030?"
+18. **Resource Constraints**: "What if you had only $10 and 1 hour?"
+19. **Metaphor Mapping**: Use extended metaphors to explore solutions
+20. **Question Storming**: Generate questions instead of answers first

package/bmad-core/data/elicitation-methods.md

@@ -0,0 +1,156 @@
+<!-- Powered by BMAD™ Core -->
+
+# Elicitation Methods Data
+
+## Core Reflective Methods
+
+**Expand or Contract for Audience**
+
+- Ask whether to 'expand' (add detail, elaborate) or 'contract' (simplify, clarify)
+- Identify specific target audience if relevant
+- Tailor content complexity and depth accordingly
+
+**Explain Reasoning (CoT Step-by-Step)**
+
+- Walk through the step-by-step thinking process
+- Reveal underlying assumptions and decision points
+- Show how conclusions were reached from current role's perspective
+
+**Critique and Refine**
+
+- Review output for flaws, inconsistencies, or improvement areas
+- Identify specific weaknesses from role's expertise
+- Suggest refined version reflecting domain knowledge
+
+## Structural Analysis Methods
+
+**Analyze Logical Flow and Dependencies**
+
+- Examine content structure for logical progression
+- Check internal consistency and coherence
+- Identify and validate dependencies between elements
+- Confirm effective ordering and sequencing
+
+**Assess Alignment with Overall Goals**
+
+- Evaluate content contribution to stated objectives
+- Identify any misalignments or gaps
+- Interpret alignment from specific role's perspective
+- Suggest adjustments to better serve goals
+
+## Risk and Challenge Methods
+
+**Identify Potential Risks and Unforeseen Issues**
+
+- Brainstorm potential risks from role's expertise
+- Identify overlooked edge cases or scenarios
+- Anticipate unintended consequences
+- Highlight implementation challenges
+
+**Challenge from Critical Perspective**
+
+- Adopt critical stance on current content
+- Play devil's advocate from specified viewpoint
+- Argue against proposal highlighting weaknesses
+- Apply YAGNI principles when appropriate (scope trimming)
+
+## Creative Exploration Methods
+
+**Tree of Thoughts Deep Dive**
+
+- Break problem into discrete "thoughts" or intermediate steps
+- Explore multiple reasoning paths simultaneously
+- Use self-evaluation to classify each path as "sure", "likely", or "impossible"
+- Apply search algorithms (BFS/DFS) to find optimal solution paths
+
+**Hindsight is 20/20: The 'If Only...' Reflection**
+
+- Imagine retrospective scenario based on current content
+- Identify the one "if only we had known/done X..." insight
+- Describe imagined consequences humorously or dramatically
+- Extract actionable learnings for current context
+
+## Multi-Persona Collaboration Methods
+
+**Agile Team Perspective Shift**
+
+- Rotate through different Scrum team member viewpoints
+- Product Owner: Focus on user value and business impact
+- Scrum Master: Examine process flow and team dynamics
+- Developer: Assess technical implementation and complexity
+- QA: Identify testing scenarios and quality concerns
+
+**Stakeholder Round Table**
+
+- Convene virtual meeting with multiple personas
+- Each persona contributes unique perspective on content
+- Identify conflicts and synergies between viewpoints
+- Synthesize insights into actionable recommendations
+
+**Meta-Prompting Analysis**
+
+- Step back to analyze the structure and logic of current approach
+- Question the format and methodology being used
+- Suggest alternative frameworks or mental models
+- Optimize the elicitation process itself
+
+## Advanced 2025 Techniques
+
+**Self-Consistency Validation**
+
+- Generate multiple reasoning paths for same problem
+- Compare consistency across different approaches
+- Identify most reliable and robust solution
+- Highlight areas where approaches diverge and why
+
+**ReWOO (Reasoning Without Observation)**
+
+- Separate parametric reasoning from tool-based actions
+- Create reasoning plan without external dependencies
+- Identify what can be solved through pure reasoning
+- Optimize for efficiency and reduced token usage
+
+**Persona-Pattern Hybrid**
+
+- Combine specific role expertise with elicitation pattern
+- Architect + Risk Analysis: Deep technical risk assessment
+- UX Expert + User Journey: End-to-end experience critique
+- PM + Stakeholder Analysis: Multi-perspective impact review
+
+**Emergent Collaboration Discovery**
+
+- Allow multiple perspectives to naturally emerge
+- Identify unexpected insights from persona interactions
+- Explore novel combinations of viewpoints
+- Capture serendipitous discoveries from multi-agent thinking
+
+## Game-Based Elicitation Methods
+
+**Red Team vs Blue Team**
+
+- Red Team: Attack the proposal, find vulnerabilities
+- Blue Team: Defend and strengthen the approach
+- Competitive analysis reveals blind spots
+- Results in more robust, battle-tested solutions
+
+**Innovation Tournament**
+
+- Pit multiple alternative approaches against each other
+- Score each approach across different criteria
+- Crowd-source evaluation from different personas
+- Identify winning combination of features
+
+**Escape Room Challenge**
+
+- Present content as constraints to work within
+- Find creative solutions within tight limitations
+- Identify minimum viable approach
+- Discover innovative workarounds and optimizations
+
+## Process Control
+
+**Proceed / No Further Actions**
+
+- Acknowledge choice to finalize current work
+- Accept output as-is or move to next step
+- Prepare to continue without additional elicitation

package/bmad-core/data/frontend-standards.md

@@ -0,0 +1,324 @@
+# Frontend Development Standards
+
+## Architecture Principles
+
+### Clean Architecture Implementation
+- **Domain Layer**: Business entities, value objects, and business rules only
+- **Application Layer**: Use cases, custom hooks, and state management
+- **Infrastructure Layer**: API clients, repositories implementations, external service adapters
+- **Presentation Layer**: React components, pages, and UI logic only
+
+### Dependency Rules
+- Inner layers must not know about outer layers
+- Dependencies point inward (from outer to inner layers)
+- Use dependency inversion for external concerns
+
+## Technology Stack Standards
+
+### Core Technologies
+- **Next.js**: 14+ with App Router and TypeScript
+- **React**: 18+ with functional components and hooks (via Next.js)
+- **TypeScript**: Strict mode enabled, no `any` types
+- **TailwindCSS**: Utility-first CSS framework
+- **Shadcn/ui + Radix UI**: Component library foundation
+
+### Framework Selection Rules
+- **Default**: Always use Next.js 14+ with App Router
+- **Exception**: Only use pure React + Vite when user specifically requests offline-first functionality
+- **Reasoning**: Next.js provides better DX, built-in optimization, and easier deployment while maintaining PWA capabilities
+
+### State Management
+- **Zustand**: Primary state management solution
+- Feature-based stores following DDD patterns
+- Global state only for truly global concerns
+- Local state for component-specific needs
+
+### Development Tools
+- **Next.js**: Built-in build system and development server
+- **Vitest**: Unit and integration testing (configured with Next.js)
+- **React Testing Library**: Component testing
+- **MSW**: API mocking for tests
+- **ESLint + Prettier**: Code quality and formatting (Next.js config)
+
+## MCP Component Strategy
+- **Always First**: Check MCP Shadcn registry before creating any component
+- **Execute MCP**: Actively run MCP commands to search and install components
+- **Workflow**: For buttons, forms, inputs, cards, dialogs, tables → Execute "Show me [type] components from shadcn registry" → Then execute "Add the [name] component to my project"
+- **Error Reduction**: 90% fewer bugs using MCP vs manual creation
+
+## Component Standards
+
+### Component Structure
+```typescript
+interface ComponentProps {
+  // Required props
+  children: React.ReactNode;
+  // Optional props with defaults
+  className?: string;
+  variant?: 'default' | 'secondary';
+  'data-testid'?: string;
+}
+
+export const Component = memo<ComponentProps>(({
+  children,
+  className,
+  variant = 'default',
+  'data-testid': testId = 'component'
+}) => {
+  // Component implementation
+  return (
+    <div className={cn(baseStyles, variantStyles[variant], className)} data-testid={testId}>
+      {children}
+    </div>
+  );
+});
+
+Component.displayName = 'Component';
+```
+
+### Component Naming
+- **PascalCase** for component names
+- **kebab-case** for file names and data-testid attributes
+- **camelCase** for props and functions
+- Descriptive names that indicate purpose
+
+### Props Guidelines
+- Always define TypeScript interfaces for props
+- Use optional props with sensible defaults
+- Include className for style overrides
+- Add data-testid for testing
+- Document complex props with JSDoc
+
+## State Management Patterns
+
+### Zustand Store Structure
+```typescript
+interface FeatureState {
+  // Domain entities
+  entities: Entity[];
+  selectedEntity: Entity | null;
+  
+  // UI state
+  loading: boolean;
+  error: string | null;
+  
+  // Actions (use case calls)
+  loadEntities: () => Promise<void>;
+  selectEntity: (id: string) => void;
+  updateEntity: (entity: Entity) => Promise<void>;
+  clearError: () => void;
+}
+
+export const useFeatureStore = create<FeatureState>()(
+  devtools(
+    (set, get) => ({
+      // Initial state
+      entities: [],
+      selectedEntity: null,
+      loading: false,
+      error: null,
+      
+      // Actions implementation
+      loadEntities: async () => {
+        set({ loading: true, error: null });
+        try {
+          const entities = await loadEntitiesUseCase.execute();
+          set({ entities, loading: false });
+        } catch (error) {
+          set({ error: error.message, loading: false });
+        }
+      },
+      
+      // Other actions...
+    }),
+    { name: 'featureStore' }
+  )
+);
+```
+
+## Testing Standards
+
+### Testing Strategy
+- **Unit Tests**: Domain entities, use cases, utilities
+- **Integration Tests**: Feature workflows, API integration
+- **Component Tests**: User interactions, accessibility
+- **E2E Tests**: Critical user journeys (minimal)
+
+### Test Structure
+```typescript
+describe('ComponentName', () => {
+  it('should render correctly with default props', () => {
+    render(<ComponentName>Test content</ComponentName>);
+    expect(screen.getByTestId('component-name')).toBeInTheDocument();
+  });
+  
+  it('should handle user interactions', async () => {
+    const handleClick = jest.fn();
+    render(<ComponentName onClick={handleClick} />);
+    
+    await user.click(screen.getByRole('button'));
+    expect(handleClick).toHaveBeenCalled();
+  });
+  
+  it('should be accessible', async () => {
+    const { container } = render(<ComponentName />);
+    const results = await axe(container);
+    expect(results).toHaveNoViolations();
+  });
+});
+```
+
+## Accessibility Standards
+
+### WCAG 2.1 AA Compliance
+- Semantic HTML elements
+- Proper heading hierarchy
+- Keyboard navigation support
+- Screen reader compatibility
+- Color contrast minimum 4.5:1
+
+### ARIA Implementation
+- Use semantic HTML first, ARIA second
+- Proper labeling with aria-label or aria-labelledby
+- Role attributes for custom components
+- State communication with aria-expanded, aria-selected
+- Live regions for dynamic content updates
+
+## Performance Standards
+
+### Bundle Optimization
+- Code splitting by route and feature
+- Lazy loading for non-critical components
+- Tree shaking for unused code
+- Bundle size budget: 500KB total
+
+### Runtime Performance
+- React.memo for expensive components
+- useMemo for expensive calculations
+- useCallback for event handlers passed to children
+- Virtual scrolling for large lists
+
+### Loading Performance
+- Image optimization and lazy loading
+- Progressive loading strategies
+- Skeleton screens for loading states
+- Prefetch critical resources
+
+## Security Guidelines
+
+### Client-Side Security
+- No API keys or secrets in frontend code
+- Input validation and sanitization
+- XSS prevention measures
+- Secure handling of user data
+
+### Authentication
+- Token-based authentication (JWT)
+- Secure token storage
+- Automatic token refresh
+- Proper logout handling
+
+## File Organization
+
+### Feature Structure
+```
+src/
+├── modules/
+│   ├── sales/                    # MODULE
+│   │   ├── quotes/              # DOMAIN
+│   │   │   ├── cart/            # FEATURE
+│   │   │   │   ├── domain/
+│   │   │   │   │   ├── entities/
+│   │   │   │   │   ├── repositories/     # Interfaces
+│   │   │   │   │   ├── services/         # Domain services
+│   │   │   │   │   └── types/
+│   │   │   │   ├── application/
+│   │   │   │   │   ├── use-cases/
+│   │   │   │   │   ├── hooks/            # Custom hooks
+│   │   │   │   │   └── store/            # Zustand store
+│   │   │   │   ├── infrastructure/
+│   │   │   │   │   ├── repositories/     # Implementations
+│   │   │   │   │   ├── api/
+│   │   │   │   │   └── adapters/
+│   │   │   │   └── presentation/
+│   │   │   │       ├── components/
+│   │   │   │       ├── pages/
+│   │   │   │       └── styles/
+│   │   │   └── products/        # FEATURE
+│   │   │       ├── domain/
+│   │   │       ├── application/
+│   │   │       ├── infrastructure/
+│   │   │       └── presentation/
+│   │   └── billing/             # DOMAIN
+│   │       ├── invoices/        # FEATURE
+│   │       └── reports/         # FEATURE
+│   ├── inventory/               # MODULE
+│   │   ├── products/            # DOMAIN
+│   │   │   ├── catalog/         # FEATURE
+│   │   │   └── stock/           # FEATURE
+│   │   └── warehouses/          # DOMAIN
+│   └── users/                   # MODULE
+│       └── authentication/      # DOMAIN
+│           ├── login/           # FEATURE
+│           └── registration/    # FEATURE
+├── shared/
+│   ├── components/              # Shadcn/ui components
+│   ├── hooks/
+│   ├── utils/
+│   ├── types/
+│   └── constants/
+├── app/
+│   ├── store/                   # Global store
+│   ├── providers/               # Context providers
+│   ├── router/                  # Routing config
+│   └── app.tsx
+├── infrastructure/
+│   ├── api/                     # API configuration
+│   ├── storage/                 # IndexedDB, localStorage
+│   └── pwa/                     # PWA configuration
+└── assets/
+```
+
+### Import Organization
+```typescript
+// External libraries
+import React from 'react';
+import { create } from 'zustand';
+
+// Internal utilities
+import { cn } from '@/lib/utils';
+
+// Types
+import type { User } from '../domain/types/User';
+
+// Components
+import { Button } from '@/components/ui/button';
+```
+
+## Error Handling
+
+### Error Boundaries
+- Feature-level error boundaries
+- Graceful fallback UI
+- Error reporting and logging
+- User-friendly error messages
+
+### API Error Handling
+- Centralized error handling in HTTP client
+- Proper error typing
+- User-friendly error messages
+- Retry mechanisms for transient errors
+
+## Progressive Web App Standards
+
+### PWA Features
+- Service worker for caching and offline support
+- Web app manifest for installability
+- Push notifications (when needed)
+- Background sync capabilities
+
+### Offline Strategy
+- Cache-first for static assets
+- Network-first for dynamic data
+- Fallback pages for offline scenarios
+- Sync when connection restored

package/bmad-core/data/technical-preferences.md

@@ -0,0 +1,5 @@
+<!-- Powered by BMAD™ Core -->
+
+# User-Defined Preferred Patterns and Preferences
+
+None Listed

package/bmad-core/data/test-levels-framework.md

@@ -0,0 +1,148 @@
+<!-- Powered by BMAD™ Core -->
+
+# Test Levels Framework
+
+Comprehensive guide for determining appropriate test levels (unit, integration, E2E) for different scenarios.
+
+## Test Level Decision Matrix
+
+### Unit Tests
+
+**When to use:**
+
+- Testing pure functions and business logic
+- Algorithm correctness
+- Input validation and data transformation
+- Error handling in isolated components
+- Complex calculations or state machines
+
+**Characteristics:**
+
+- Fast execution (immediate feedback)
+- No external dependencies (DB, API, file system)
+- Highly maintainable and stable
+- Easy to debug failures
+
+**Example scenarios:**
+
+```yaml
+unit_test:
+  component: 'PriceCalculator'
+  scenario: 'Calculate discount with multiple rules'
+  justification: 'Complex business logic with multiple branches'
+  mock_requirements: 'None - pure function'
+```
+
+### Integration Tests
+
+**When to use:**
+
+- Component interaction verification
+- Database operations and transactions
+- API endpoint contracts
+- Service-to-service communication
+- Middleware and interceptor behavior
+
+**Characteristics:**
+
+- Moderate execution time
+- Tests component boundaries
+- May use test databases or containers
+- Validates system integration points
+
+**Example scenarios:**
+
+```yaml
+integration_test:
+  components: ['UserService', 'AuthRepository']
+  scenario: 'Create user with role assignment'
+  justification: 'Critical data flow between service and persistence'
+  test_environment: 'In-memory database'
+```
+
+### End-to-End Tests
+
+**When to use:**
+
+- Critical user journeys
+- Cross-system workflows
+- Visual regression testing
+- Compliance and regulatory requirements
+- Final validation before release
+
+**Characteristics:**
+
+- Slower execution
+- Tests complete workflows
+- Requires full environment setup
+- Most realistic but most brittle
+
+**Example scenarios:**
+
+```yaml
+e2e_test:
+  journey: 'Complete checkout process'
+  scenario: 'User purchases with saved payment method'
+  justification: 'Revenue-critical path requiring full validation'
+  environment: 'Staging with test payment gateway'
+```
+
+## Test Level Selection Rules
+
+### Favor Unit Tests When:
+
+- Logic can be isolated
+- No side effects involved
+- Fast feedback needed
+- High cyclomatic complexity
+
+### Favor Integration Tests When:
+
+- Testing persistence layer
+- Validating service contracts
+- Testing middleware/interceptors
+- Component boundaries critical
+
+### Favor E2E Tests When:
+
+- User-facing critical paths
+- Multi-system interactions
+- Regulatory compliance scenarios
+- Visual regression important
+
+## Anti-patterns to Avoid
+
+- E2E testing for business logic validation
+- Unit testing framework behavior
+- Integration testing third-party libraries
+- Duplicate coverage across levels
+
+## Duplicate Coverage Guard
+
+**Before adding any test, check:**
+
+1. Is this already tested at a lower level?
+2. Can a unit test cover this instead of integration?
+3. Can an integration test cover this instead of E2E?
+
+**Coverage overlap is only acceptable when:**
+
+- Testing different aspects (unit: logic, integration: interaction, e2e: user experience)
+- Critical paths requiring defense in depth
+- Regression prevention for previously broken functionality
+
+## Test Naming Conventions
+
+- Unit: `test_{component}_{scenario}`
+- Integration: `test_{flow}_{interaction}`
+- E2E: `test_{journey}_{outcome}`
+
+## Test ID Format
+
+`{EPIC}.{STORY}-{LEVEL}-{SEQ}`
+
+Examples:
+
+- `1.3-UNIT-001`
+- `1.3-INT-002`
+- `1.3-E2E-001`