siesa-agents 1.0.0 → 1.0.1

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

@@ -1,38 +0,0 @@
-<!-- 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

@@ -1,156 +0,0 @@
-<!-- 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

@@ -1,324 +0,0 @@
-# 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

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

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

@@ -1,148 +0,0 @@
-<!-- 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`