bmad-elsabro 1.0.0

package/renderer/renderer/components/NOTIFICATION_SYSTEM.md

@@ -0,0 +1,192 @@
+# Notification System
+
+A comprehensive notification system for BMAD Studio with support for multiple notification types, auto-dismissal, manual dismissal, and action buttons.
+
+## Components
+
+### NotificationCenter
+
+Fixed-position component that displays notifications with smooth animations.
+
+**Features:**
+- Multiple notification types (success, error, warning, info)
+- Auto-dismiss with configurable timeout
+- Manual dismissal via close button
+- Smooth enter/exit animations
+- Stacking support for multiple notifications
+- Dark/light theme support
+- Progress bar showing remaining time
+- ARIA live regions for accessibility
+
+### useNotifications Hook
+
+Custom React hook for managing notification state and lifecycle.
+
+**Features:**
+- Add notifications with `success()`, `error()`, `warning()`, `info()`, or `notify()`
+- Dismiss individual notifications with `dismiss(id)`
+- Clear all notifications with `clearAll()`
+- Configurable auto-dismiss duration
+- Optional action buttons
+- Unique ID generation
+
+## Usage
+
+### Basic Setup
+
+```tsx
+import React from 'react';
+import NotificationCenter from './components/NotificationCenter';
+import { useNotifications } from './hooks/useNotifications';
+
+function App() {
+  const { notifications, success, error, warning, info, dismiss } = useNotifications();
+
+  return (
+    <div>
+      {/* Your app content */}
+
+      {/* Add NotificationCenter anywhere in your component tree */}
+      <NotificationCenter
+        notifications={notifications}
+        onDismiss={dismiss}
+        position="top-right"
+      />
+    </div>
+  );
+}
+```
+
+### Showing Notifications
+
+```tsx
+// Success notification (auto-dismisses after 5 seconds)
+success('Operation completed successfully!');
+
+// Error notification (does not auto-dismiss by default)
+error('An error occurred', {
+  description: 'Please check your input and try again.'
+});
+
+// Warning notification
+warning('This action cannot be undone!', {
+  duration: 10000 // Custom 10-second duration
+});
+
+// Info notification with action button
+info('New update available', {
+  description: 'Version 1.1.0 is ready to install.',
+  action: {
+    label: 'Update Now',
+    onClick: () => {
+      // Handle update
+    }
+  }
+});
+
+// Custom notification with all options
+notify('success', 'Custom notification', {
+  description: 'Optional detailed description',
+  duration: 7000, // 7 seconds
+  dismissible: true, // Show dismiss button
+  action: {
+    label: 'View Details',
+    onClick: () => console.log('Action clicked')
+  }
+});
+```
+
+### Advanced Options
+
+```tsx
+// Notification that never auto-dismisses
+error('Critical error', {
+  duration: 0, // 0 = no auto-dismiss
+  dismissible: true
+});
+
+// Non-dismissible notification (e.g., for system messages)
+info('System maintenance in progress', {
+  duration: 0,
+  dismissible: false
+});
+
+// Get notification ID for manual control
+const id = success('Processing...');
+// Later, dismiss it manually
+dismiss(id);
+
+// Clear all notifications at once
+clearAll();
+```
+
+### Configuration
+
+**NotificationCenter Props:**
+- `notifications` (required): Array of notifications from `useNotifications` hook
+- `onDismiss` (required): Callback function to dismiss notifications
+- `position`: Position of notification center (default: `'top-right'`)
+  - Options: `'top-right'`, `'top-left'`, `'bottom-right'`, `'bottom-left'`
+- `maxVisible`: Maximum number of notifications to display (default: `5`)
+- `className`: Optional custom CSS class
+
+**Notification Options:**
+- `type`: Notification type (`'success'`, `'error'`, `'warning'`, `'info'`)
+- `message`: Main notification message (required)
+- `description`: Optional detailed description
+- `duration`: Auto-dismiss timeout in milliseconds (default: `5000` for most types, `0` for errors)
+- `dismissible`: Whether notification can be manually dismissed (default: `true`)
+- `action`: Optional action button with `label` and `onClick` callback
+
+## Notification Types
+
+### Success (Green)
+- Icon: ✓
+- Default duration: 5 seconds
+- Use for: Successful operations, confirmations
+
+### Error (Red)
+- Icon: ✕
+- Default duration: Never (0)
+- Use for: Errors, failures, critical issues
+
+### Warning (Yellow)
+- Icon: ⚠
+- Default duration: 5 seconds
+- Use for: Warnings, cautions, important notices
+
+### Info (Blue)
+- Icon: ℹ
+- Default duration: 5 seconds
+- Use for: Information, updates, tips
+
+## Styling
+
+The notification system uses TailwindCSS utility classes and supports dark mode automatically through the `dark:` variants.
+
+Custom animations are defined in `renderer/styles.css`:
+- `slideInRight`: Entrance animation
+- `slideOutRight`: Exit animation
+
+## Accessibility
+
+- Uses ARIA `role="alert"` and `aria-live="polite"`
+- Keyboard accessible dismiss buttons
+- Focus management for action buttons
+- Screen reader friendly labels
+
+## Best Practices
+
+1. **Use appropriate types**: Match notification type to the message severity
+2. **Keep messages concise**: Main message should be brief, use description for details
+3. **Don't overuse**: Too many notifications can overwhelm users
+4. **Auto-dismiss appropriately**:
+   - Success/Info: 5 seconds is usually enough
+   - Warning: 7-10 seconds for important notices
+   - Error: Don't auto-dismiss unless trivial
+5. **Provide actions when helpful**: If user can take action, include an action button
+6. **Test with multiple notifications**: Ensure stacking behavior works correctly
+
+## Examples
+
+See `renderer/App.tsx` for a complete working example with demo buttons for each notification type.

package/renderer/styles.css

@@ -0,0 +1,55 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* Custom styles for BMAD Studio */
+body {
+  margin: 0;
+  padding: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
+    monospace;
+}
+
+#root {
+  width: 100%;
+  height: 100%;
+}
+
+/* Notification animations */
+@keyframes slideInRight {
+  from {
+    transform: translateX(100%);
+    opacity: 0;
+  }
+  to {
+    transform: translateX(0);
+    opacity: 1;
+  }
+}
+
+@keyframes slideOutRight {
+  from {
+    transform: translateX(0);
+    opacity: 1;
+  }
+  to {
+    transform: translateX(100%);
+    opacity: 0;
+  }
+}
+
+.animate-slideInRight {
+  animation: slideInRight 0.3s ease-out;
+}
+
+.animate-slideOutRight {
+  animation: slideOutRight 0.3s ease-in;
+}

package/renderer/types/css-modules.d.ts

@@ -0,0 +1,21 @@
+/**
+ * CSS Modules Type Definitions
+ *
+ * This file provides TypeScript support for CSS Module imports.
+ * It allows importing .module.css files with proper type checking.
+ */
+
+declare module '*.module.css' {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.scss' {
+  const classes: { [key: string]: string };
+  export default classes;
+}
+
+declare module '*.module.sass' {
+  const classes: { [key: string]: string };
+  export default classes;
+}

package/renderer/types/electron.d.ts

@@ -0,0 +1,316 @@
+/**
+ * TypeScript declarations for Electron IPC API
+ *
+ * Defines the types for window.electron API exposed by preload script.
+ *
+ * @module renderer/types/electron
+ */
+
+/**
+ * Workflow data structure
+ */
+interface WorkflowData {
+  id: string;
+  name: string;
+  nodes: unknown[];
+  edges: unknown[];
+  createdAt: string | Date;
+  updatedAt: string | Date;
+}
+
+/**
+ * Workflow list item
+ */
+interface WorkflowListItem {
+  id: string;
+  name: string;
+  path: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+/**
+ * Party Mode Agent
+ */
+interface PartyAgent {
+  id: string;
+  displayName: string;
+  title: string;
+  icon: string;
+  role: string;
+  identity: string;
+  communicationStyle: string;
+  principles?: string;
+  module?: string;
+  path?: string;
+  status: 'idle' | 'thinking' | 'speaking' | 'active';
+  contributions: number;
+}
+
+/**
+ * Party Mode Message
+ */
+interface PartyMessage {
+  id: string;
+  agentId: string;
+  agentName: string;
+  content: string;
+  timestamp: number;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Party Mode Session
+ */
+interface PartySession {
+  sessionId: string;
+  startTime: number;
+  endTime?: number;
+  agents: PartyAgent[];
+  messageHistory: PartyMessage[];
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Agent Selection Criteria
+ */
+interface AgentSelectionCriteria {
+  count?: number;
+  preferredAgents?: string[];
+  requiredRole?: string;
+  balanceContributions?: boolean;
+  topic?: string;
+}
+
+/**
+ * Session Statistics
+ */
+interface PartySessionStats {
+  totalMessages: number;
+  agentContributions: Record<string, number>;
+  sessionDuration: number;
+  activeAgents: number;
+}
+
+/**
+ * Project type detection result
+ */
+interface ProjectTypeResult {
+  id: string;
+  name: string;
+  category: string;
+  confidence: number;
+}
+
+/**
+ * Project size information
+ */
+interface ProjectSize {
+  id: string;
+  name: string;
+  fileCount: number;
+  totalLines: number;
+  totalSize: number;
+}
+
+/**
+ * Project detection metadata
+ */
+interface ProjectDetectionMeta {
+  projectPath: string;
+  analyzedAt: string;
+  analysisTimeMs: number;
+}
+
+/**
+ * Complete project detection result
+ */
+interface ProjectDetectionResult {
+  types: ProjectTypeResult[];
+  size: ProjectSize;
+  meta: ProjectDetectionMeta;
+}
+
+/**
+ * Electron API interface exposed to renderer process
+ */
+interface ElectronAPI {
+  send: (channel: string, data: unknown) => void;
+  receive: (channel: string, func: (...args: unknown[]) => void) => void;
+  invoke: (channel: string, data?: unknown) => Promise<unknown>;
+}
+
+/**
+ * Platform information interface
+ */
+interface PlatformAPI {
+  os: string;
+  arch: string;
+  version: string;
+}
+
+/**
+ * Party Mode API
+ */
+interface PartyAPI {
+  getAgents: () => Promise<PartyAgent[]>;
+  startSession: (sessionId?: string, selectedAgentIds?: string[]) => Promise<PartySession>;
+  endSession: () => Promise<PartySession | null>;
+  getCurrentSession: () => Promise<PartySession | null>;
+  getSessionAgents: () => Promise<PartyAgent[]>;
+  selectAgents: (criteria: AgentSelectionCriteria) => Promise<PartyAgent[]>;
+  updateAgentStatus: (agentId: string, status: PartyAgent['status']) => Promise<void>;
+  recordContribution: (agentId: string) => Promise<void>;
+  addMessage: (message: Omit<PartyMessage, 'id' | 'timestamp'>) => Promise<PartyMessage>;
+  getMessageHistory: () => Promise<PartyMessage[]>;
+  getSessionStats: () => Promise<PartySessionStats>;
+  reset: () => Promise<void>;
+}
+
+/**
+ * Project Detector API
+ */
+interface ProjectAPI {
+  detect: (projectPath: string) => Promise<ProjectDetectionResult>;
+  getPrimaryType: (projectPath: string) => Promise<string | null>;
+  isType: (projectPath: string, typeId: string, minConfidence?: number) => Promise<boolean>;
+}
+
+/**
+ * Legacy project information
+ */
+interface LegacyProjectInfo {
+  isLegacy: boolean;
+  version?: string;
+  projectPath: string;
+  directories: {
+    agents?: string;
+    workflows?: string;
+    config?: string;
+    steps?: string;
+  };
+  counts: {
+    agents: number;
+    workflows: number;
+    steps: number;
+    hasConfig: boolean;
+  };
+  issues: string[];
+}
+
+/**
+ * Migration step
+ */
+interface MigrationStep {
+  id: string;
+  name: string;
+  description: string;
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+  progress: number;
+  error?: string;
+}
+
+/**
+ * Migration result
+ */
+interface MigrationResult {
+  success: boolean;
+  steps: MigrationStep[];
+  migrated: {
+    agents: number;
+    workflows: number;
+    config: boolean;
+  };
+  backupPath?: string;
+  error?: string;
+  completedAt: string;
+}
+
+/**
+ * Migration options
+ */
+interface MigrationOptions {
+  sourcePath: string;
+  createBackup?: boolean;
+  preserveOriginal?: boolean;
+  skipSteps?: string[];
+}
+
+/**
+ * Legacy Migrator API
+ */
+interface LegacyMigratorAPI {
+  detect: (projectPath: string) => Promise<{ success: boolean; data?: LegacyProjectInfo; error?: string }>;
+  migrate: (options: MigrationOptions) => Promise<{ success: boolean; data?: MigrationResult; error?: string }>;
+  rollback: (backupPath: string, targetPath: string) => Promise<{ success: boolean; data?: boolean; error?: string }>;
+  on: (event: string, callback: (...args: unknown[]) => void) => void;
+  off: (event: string) => void;
+}
+
+/**
+ * Flow type for workflow routing
+ */
+type FlowType = 'quick-flow' | 'full-method';
+
+/**
+ * Complexity level
+ */
+type ComplexityLevel = 'trivial' | 'simple' | 'moderate' | 'complex' | 'enterprise';
+
+/**
+ * Task analysis input for workflow router
+ */
+interface TaskAnalysisInput {
+  taskDescription: string;
+  projectType?: string;
+  projectSize?: 'tiny' | 'small' | 'medium' | 'large' | 'huge';
+  fileCount?: number;
+  userPreference?: FlowType;
+}
+
+/**
+ * Routing decision from workflow router
+ */
+interface RoutingDecision {
+  recommendedFlow: FlowType;
+  confidence: number;
+  complexity: ComplexityLevel;
+  reasoning: string;
+  characteristics: {
+    isNewProduct: boolean;
+    isMajorFeature: boolean;
+    requiresMultipleTeams: boolean;
+    requiresStakeholderAlignment: boolean;
+    isBugFix: boolean;
+    isRefactoring: boolean;
+    isSmallFeature: boolean;
+    isPrototype: boolean;
+  };
+  matchedKeywords: string[];
+}
+
+/**
+ * Workflow Router API
+ */
+interface WorkflowRouterAPI {
+  analyzeTask: (input: TaskAnalysisInput) => Promise<RoutingDecision>;
+  getFlowDescription: (flow: FlowType) => Promise<string>;
+  getComplexityDescription: (complexity: ComplexityLevel) => Promise<string>;
+}
+
+/**
+ * Extend Window interface with Electron APIs
+ */
+declare global {
+  interface Window {
+    electron: ElectronAPI & {
+      party: PartyAPI;
+      project: ProjectAPI;
+      legacyMigrator: LegacyMigratorAPI;
+      workflowRouter: WorkflowRouterAPI;
+    };
+    platform: PlatformAPI;
+  }
+}
+
+export {};

package/src/bmm/_module-installer/installer.js

@@ -0,0 +1,48 @@
+const fs = require('fs-extra');
+const path = require('node:path');
+const chalk = require('chalk');
+
+// Directories to create from config
+const DIRECTORIES = ['output_folder', 'planning_artifacts', 'implementation_artifacts'];
+
+/**
+ * BMM Module Installer
+ * Creates output directories configured in module config
+ *
+ * @param {Object} options - Installation options
+ * @param {string} options.projectRoot - The root directory of the target project
+ * @param {Object} options.config - Module configuration from module.yaml
+ * @param {Array<string>} options.installedIDEs - Array of IDE codes that were installed
+ * @param {Object} options.logger - Logger instance for output
+ * @returns {Promise<boolean>} - Success status
+ */
+async function install(options) {
+  const { projectRoot, config, logger } = options;
+
+  try {
+    logger.log(chalk.blue('🚀 Installing BMM Module...'));
+
+    // Create configured directories
+    for (const configKey of DIRECTORIES) {
+      const configValue = config[configKey];
+      if (!configValue) continue;
+
+      const dirPath = configValue.replace('{project-root}/', '');
+      const fullPath = path.join(projectRoot, dirPath);
+
+      if (!(await fs.pathExists(fullPath))) {
+        const dirName = configKey.replace('_', ' ');
+        logger.log(chalk.yellow(`Creating ${dirName} directory: ${dirPath}`));
+        await fs.ensureDir(fullPath);
+      }
+    }
+
+    logger.log(chalk.green('✓ BMM Module installation complete'));
+    return true;
+  } catch (error) {
+    logger.error(chalk.red(`Error installing BMM module: ${error.message}`));
+    return false;
+  }
+}
+
+module.exports = { install };

package/src/bmm/agents/analyst.agent.yaml

@@ -0,0 +1,36 @@
+# Business Analyst Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/bmm/agents/analyst.md"
+    name: Mary
+    title: Business Analyst
+    icon: 📊
+    module: bmm
+    hasSidecar: false
+
+  persona:
+    role: Strategic Business Analyst + Requirements Expert
+    identity: Senior analyst with deep expertise in market research, competitive analysis, and requirements elicitation. Specializes in translating vague needs into actionable specs.
+    communication_style: "Speaks with the excitement of a treasure hunter - thrilled by every clue, energized when patterns emerge. Structures insights with precision while making analysis feel like discovery."
+    principles: |
+      - Channel expert business analysis frameworks: draw upon Porter's Five Forces, SWOT analysis, root cause analysis, and competitive intelligence methodologies to uncover what others miss. Every business challenge has root causes waiting to be discovered. Ground findings in verifiable evidence.
+      - Articulate requirements with absolute precision. Ensure all stakeholder voices heard.
+
+  menu:
+    - trigger: BP or fuzzy match on brainstorm-project
+      exec: "{project-root}/_bmad/core/workflows/brainstorming/workflow.md"
+      data: "{project-root}/_bmad/bmm/data/project-context-template.md"
+      description: "[BP] Brainstorm Project: Expert Guided Facilitation through a single or multiple techniques with a final report"
+
+    - trigger: RS or fuzzy match on research
+      exec: "{project-root}/_bmad/bmm/workflows/1-analysis/research/workflow.md"
+      description: "[RS] Research: Choose from or specify market, domain, competitive analysis, or technical research"
+
+    - trigger: CB or fuzzy match on product-brief
+      exec: "{project-root}/_bmad/bmm/workflows/1-analysis/create-product-brief/workflow.md"
+      description: "[CB] Create Brief: A guided experience to nail down your product idea into an executive brief"
+
+    - trigger: DP or fuzzy match on document-project
+      workflow: "{project-root}/_bmad/bmm/workflows/document-project/workflow.yaml"
+      description: "[DP] Document Project: Analyze an existing project to produce useful documentation for both human and LLM"

package/src/bmm/agents/architect.agent.yaml

@@ -0,0 +1,28 @@
+# Architect Agent Definition
+
+agent:
+  metadata:
+    id: "_bmad/bmm/agents/architect.md"
+    name: Winston
+    title: Architect
+    icon: 🏗️
+    module: bmm
+    hasSidecar: false
+
+  persona:
+    role: System Architect + Technical Design Leader
+    identity: Senior architect with expertise in distributed systems, cloud infrastructure, and API design. Specializes in scalable patterns and technology selection.
+    communication_style: "Speaks in calm, pragmatic tones, balancing 'what could be' with 'what should be.'"
+    principles: |
+      - Channel expert lean architecture wisdom: draw upon deep knowledge of distributed systems, cloud patterns, scalability trade-offs, and what actually ships successfully
+      - User journeys drive technical decisions. Embrace boring technology for stability.
+      - Design simple solutions that scale when needed. Developer productivity is architecture. Connect every decision to business value and user impact.
+
+  menu:
+    - trigger: CA or fuzzy match on create-architecture
+      exec: "{project-root}/_bmad/bmm/workflows/3-solutioning/create-architecture/workflow.md"
+      description: "[CA] Create Architecture: Guided Workflow to document technical decisions to keep implementation on track"
+
+    - trigger: IR or fuzzy match on implementation-readiness
+      exec: "{project-root}/_bmad/bmm/workflows/3-solutioning/check-implementation-readiness/workflow.md"
+      description: "[IR] Implementation Readiness: Ensure the PRD, UX, and Architecture and Epics and Stories List are all aligned"