bmad-elsabro 1.0.0

package/PARTY_MODE_VERIFICATION.md

@@ -0,0 +1,274 @@
+# Party Mode Verification Guide
+
+## Overview
+
+Party Mode is a multi-agent coordination UI that enables collaborative discussions between multiple BMAD agents. This guide explains how to verify the implementation.
+
+## Architecture
+
+### Components Created
+
+1. **renderer/components/PartyMode.tsx**
+   - Multi-agent conversation UI
+   - Agent roster sidebar
+   - Real-time status indicators
+   - Message input and display
+
+2. **electron/services/party-coordinator.ts**
+   - Agent session management
+   - Intelligent agent selection
+   - Contribution tracking
+   - Conversation history
+
+3. **electron/ipc/party-handler.ts**
+   - 11 IPC handlers for party operations
+   - Secure main-to-renderer communication
+
+## Features
+
+### Agent Roster
+- Displays all active agents in sidebar
+- Shows agent icon, name, title, and contribution count
+- Real-time status indicators:
+  - 🟢 **Idle** - Agent available
+  - 🟡 **Thinking** - Agent processing
+  - 🔵 **Speaking** - Agent responding
+  - ✅ **Active** - Agent has contributed
+
+### Conversation Orchestration
+- User sends messages
+- System selects 2-3 relevant agents to respond
+- Agents respond sequentially with streaming
+- Conversation history maintained
+- Exit triggers: `*exit`, `goodbye`, `end party`, `quit`
+
+### Default Agents
+1. 🎯 **BMAD Master** - Chief Architect
+2. 🔍 **Code Reviewer** - Quality Assurance Lead
+3. 🧪 **Test Engineer** - Testing Specialist
+4. 🎨 **UX Designer** - User Experience Lead
+5. ⚙️ **DevOps Engineer** - Infrastructure Specialist
+
+## Manual Verification Steps
+
+### Test 1: Basic Party Mode Launch
+
+1. Start the application:
+   ```bash
+   npm run electron:dev
+   ```
+
+2. Navigate to Party Mode (when integrated into app navigation)
+
+3. Verify:
+   - ✅ Party Mode UI loads
+   - ✅ Welcome message appears
+   - ✅ Agent roster sidebar displays all 5 default agents
+   - ✅ All agents show status "idle"
+   - ✅ Contribution counts are 0
+
+### Test 2: Multi-Agent Conversation
+
+1. Type a message: "Hello team, I need help with testing"
+
+2. Press Enter or click Send
+
+3. Verify:
+   - ✅ User message appears in conversation
+   - ✅ 2-3 agents show "thinking" status (yellow indicator)
+   - ✅ Agents respond sequentially
+   - ✅ Each agent shows "speaking" status while responding
+   - ✅ Agent messages display with agent name and icon
+   - ✅ Contribution counts increment for responding agents
+   - ✅ Agents return to "active" or "idle" status after responding
+
+### Test 3: Agent Roster Toggle
+
+1. Click "Hide Roster" button in header
+
+2. Verify:
+   - ✅ Agent roster sidebar disappears
+   - ✅ Conversation panel expands to full width
+
+3. Click "Show Roster" button
+
+4. Verify:
+   - ✅ Agent roster reappears
+   - ✅ Layout returns to original state
+
+### Test 4: Exit Party Mode
+
+1. Type one of the exit triggers: "goodbye"
+
+2. Press Enter
+
+3. Verify:
+   - ✅ Farewell message appears
+   - ✅ Party Mode ends gracefully (if onEnd callback is provided)
+
+### Test 5: Keyboard Shortcuts
+
+1. Focus on message input
+
+2. Test keyboard shortcuts:
+   - ✅ **Enter** - Sends message
+   - ✅ **Shift+Enter** - Adds new line
+   - ✅ **Escape** - Clears input
+
+### Test 6: Dark/Light Theme
+
+1. Toggle theme in app header
+
+2. Verify:
+   - ✅ Party Mode UI adapts to theme
+   - ✅ Agent roster colors update
+   - ✅ Messages remain readable
+   - ✅ Status indicators visible in both themes
+
+## API Testing (Optional)
+
+If you want to test the Party Mode API directly:
+
+```typescript
+// Get all available agents
+const agents = await window.electron.party.getAgents();
+console.log('Available agents:', agents);
+
+// Start a party session with specific agents
+const session = await window.electron.party.startSession(
+  'test-session',
+  ['bmad-master', 'code-reviewer']
+);
+console.log('Session started:', session);
+
+// Get session statistics
+const stats = await window.electron.party.getSessionStats();
+console.log('Session stats:', stats);
+
+// End session
+const endedSession = await window.electron.party.endSession();
+console.log('Session ended:', endedSession);
+```
+
+## Integration with App
+
+To integrate Party Mode into the main application:
+
+1. **Add to navigation sidebar** (renderer/components/Sidebar.tsx):
+   ```tsx
+   {
+     label: 'Party Mode',
+     icon: '🎉',
+     path: '/party-mode',
+     onClick: () => navigate('/party-mode')
+   }
+   ```
+
+2. **Add route** (if using React Router):
+   ```tsx
+   <Route path="/party-mode" element={<PartyMode />} />
+   ```
+
+3. **Or use as modal**:
+   ```tsx
+   const [showPartyMode, setShowPartyMode] = useState(false);
+
+   {showPartyMode && (
+     <PartyMode onEnd={() => setShowPartyMode(false)} />
+   )}
+   ```
+
+## Expected Behavior
+
+### Session Flow
+1. User opens Party Mode
+2. Welcome message displays with agent introductions
+3. User asks questions or starts discussion
+4. System selects relevant agents based on:
+   - Topic/expertise match
+   - Contribution balance
+   - Agent availability
+5. Selected agents respond in sequence
+6. Conversation continues until user exits
+
+### Agent Selection Logic
+- Default: Select 2-3 least active agents
+- Balance contributions over time
+- Prefer agents matching topic/role requirements
+- Allow manual agent selection via API
+
+## Troubleshooting
+
+### Agents Not Responding
+- Check that `getAgentResponse()` is properly implemented
+- Verify IPC handlers are loaded (check electron/main.ts)
+- Check console for errors
+
+### Roster Not Loading
+- Verify agents are loaded in party-coordinator
+- Check `getAgents()` IPC handler
+- Inspect console for manifest loading errors
+
+### TypeScript Errors
+- Ensure electron.d.ts types are loaded
+- Check that preload script exposes party API
+- Verify IPC channel names match between handler and preload
+
+## Future Enhancements
+
+1. **AI Integration**
+   - Replace mock responses with actual AI generation
+   - Implement streaming responses from AI service
+   - Add agent personality prompts
+
+2. **Agent Customization**
+   - Load agents from YAML/CSV manifest
+   - Custom agent creation UI
+   - Agent personality editor
+
+3. **Advanced Features**
+   - Agent-to-agent conversations (cross-talk)
+   - Topic-based agent selection
+   - Conversation branching
+   - Export conversation transcripts
+   - Save/load party sessions
+
+## Success Criteria
+
+✅ Party Mode launches successfully
+✅ All 5 default agents appear in roster
+✅ User can send messages
+✅ Multiple agents respond sequentially
+✅ Agent status updates in real-time
+✅ Contribution counts increment correctly
+✅ Roster toggle works
+✅ Exit triggers end session gracefully
+✅ Dark/light themes supported
+✅ No console errors
+✅ TypeScript compilation passes
+
+## Notes
+
+- Current implementation uses **mock responses** for demonstration
+- In production, integrate with actual AI service for agent responses
+- Agent manifest can be loaded from CSV file at:
+  `{userData}/_bmad/_config/agent-manifest.csv`
+- Default agents created if manifest not found
+- All IPC communication is secure via contextBridge
+- Session state persists until explicitly ended
+
+## Related Files
+
+- `renderer/components/PartyMode.tsx` - UI Component
+- `electron/services/party-coordinator.ts` - Coordination Service
+- `electron/ipc/party-handler.ts` - IPC Handlers
+- `electron/main.ts` - Handler Setup
+- `electron/preload.ts` - API Exposure
+- `renderer/types/electron.d.ts` - Type Definitions
+
+---
+
+**Implementation Status:** ✅ Complete
+**Commit:** 1206bb05
+**Subtask:** subtask-6-5
+**Phase:** Visual Workflow Editor (Phase 6)

package/PROJECT_DETECTOR_TESTING.md

@@ -0,0 +1,288 @@
+# Project Detector Testing Guide
+
+## Overview
+
+This guide provides instructions for manually verifying the project type and size auto-detection feature.
+
+## Quick Test (Automated)
+
+Run the verification script to test the project detector on the current BMAD Studio project:
+
+```bash
+npx ts-node test/verify-project-detector.ts
+```
+
+**Expected Output:**
+- Should detect **Electron** project (high confidence >80%)
+- Should detect **React** project (high confidence >80%)
+- Should detect **TypeScript** project (high confidence >80%)
+- Should detect **Node.js** project (medium confidence ~50-70%)
+- Project size: **Medium** or **Large** category
+- Analysis time: < 5000ms
+
+## Manual Testing in Electron App
+
+### Setup
+
+1. Start the Electron app in development mode:
+   ```bash
+   npm run electron:dev
+   ```
+
+2. Open the browser DevTools (automatically opens in development mode)
+
+### Test 1: Detect Current Project
+
+In the DevTools Console, run:
+
+```javascript
+// Detect the current BMAD Studio project
+const result = await window.electron.project.detect(process.cwd());
+console.log('Detection Result:', result);
+```
+
+**Expected:**
+```javascript
+{
+  types: [
+    { id: 'electron', name: 'Electron', category: 'desktop', confidence: 85 },
+    { id: 'react', name: 'React', category: 'frontend', confidence: 80 },
+    { id: 'typescript', name: 'TypeScript', category: 'general', confidence: 75 },
+    { id: 'nodejs', name: 'Node.js', category: 'backend', confidence: 60 }
+  ],
+  size: {
+    id: 'medium',
+    name: 'Medium',
+    fileCount: 500-1000,
+    totalLines: 50000-100000,
+    totalSize: 10-50MB
+  },
+  meta: {
+    projectPath: '/path/to/project',
+    analyzedAt: '2026-01-29T...',
+    analysisTimeMs: 2000-5000
+  }
+}
+```
+
+### Test 2: Detect a React Project
+
+1. Create or navigate to a React project directory
+2. Run in DevTools Console:
+
+```javascript
+const reactPath = '/path/to/your/react/project';
+const result = await window.electron.project.detect(reactPath);
+console.log('React Project:', result);
+```
+
+**Expected:**
+- Should detect `react` as primary type with high confidence (>70%)
+- May also detect `nodejs`, `typescript`, or `javascript`
+- Size category depends on project (typically Small or Medium)
+
+### Test 3: Get Primary Type
+
+```javascript
+// Get just the primary type (highest confidence)
+const primaryType = await window.electron.project.getPrimaryType(process.cwd());
+console.log('Primary Type:', primaryType); // Should be 'electron' or 'react'
+```
+
+### Test 4: Check Specific Type
+
+```javascript
+// Check if project is React with at least 50% confidence
+const isReact = await window.electron.project.isType(
+  process.cwd(),
+  'react',
+  50
+);
+console.log('Is React?', isReact); // Should be true
+
+// Check with higher threshold
+const isReactHighConfidence = await window.electron.project.isType(
+  process.cwd(),
+  'react',
+  90
+);
+console.log('Is React (90%+)?', isReactHighConfidence); // May be false
+```
+
+## Test Cases by Project Type
+
+### Vue.js Project
+
+**Signatures:**
+- `package.json` with `vue` dependency
+- `vue.config.js` or `vite.config.js` present
+- `src/components` directory exists
+- `.vue` files present
+
+**Expected Detection:**
+- Primary type: `vue`
+- Category: `frontend`
+- Confidence: High (>70%)
+
+### Angular Project
+
+**Signatures:**
+- `angular.json` file present
+- `@angular/core` dependency
+- `src/app` directory exists
+- `*.component.ts` files present
+
+**Expected Detection:**
+- Primary type: `angular`
+- Category: `frontend`
+- Confidence: High (>70%)
+
+### Next.js Project
+
+**Signatures:**
+- `next.config.js` file present
+- `next` and `react` dependencies
+- `pages` or `app` directory exists
+
+**Expected Detection:**
+- Primary type: `nextjs`
+- Category: `fullstack`
+- Confidence: High (>80%)
+
+### Python/Django Project
+
+**Signatures:**
+- `requirements.txt` or `setup.py` present
+- `manage.py` for Django
+- `*.py` files present
+
+**Expected Detection:**
+- Primary type: `django` or `python`
+- Category: `backend`
+- Confidence: Medium to High (>60%)
+
+## Size Category Testing
+
+Test with projects of different sizes:
+
+| Category | File Count | Lines of Code | Total Size |
+|----------|-----------|---------------|------------|
+| Tiny | < 50 | < 5,000 | < 1 MB |
+| Small | < 200 | < 20,000 | < 10 MB |
+| Medium | < 1,000 | < 100,000 | < 50 MB |
+| Large | < 5,000 | < 500,000 | < 250 MB |
+| Huge | > 5,000 | > 500,000 | > 250 MB |
+
+## Performance Testing
+
+Monitor analysis time in the `meta.analysisTimeMs` field:
+
+- **Tiny projects**: < 500ms
+- **Small projects**: < 1000ms
+- **Medium projects**: < 2000ms
+- **Large projects**: < 5000ms
+- **Huge projects**: < 10000ms
+
+If analysis takes longer than expected, check:
+1. Project is using git (faster file discovery)
+2. `.gitignore` is properly configured
+3. `node_modules` and other large directories are ignored
+
+## Integration with UI
+
+The project detector can be integrated into:
+
+1. **Project Import Wizard**: Auto-detect project type when user selects a directory
+2. **Dashboard**: Display project type badges
+3. **Template Selector**: Recommend templates based on detected type
+4. **Workflow Router**: Suggest Quick Flow vs Full Method based on project size
+
+Example integration in React component:
+
+```typescript
+import { useEffect, useState } from 'react';
+
+function ProjectInfo({ projectPath }: { projectPath: string }) {
+  const [detection, setDetection] = useState<ProjectDetectionResult | null>(null);
+
+  useEffect(() => {
+    async function detectProject() {
+      const result = await window.electron.project.detect(projectPath);
+      setDetection(result);
+    }
+    detectProject();
+  }, [projectPath]);
+
+  if (!detection) return <div>Detecting project...</div>;
+
+  return (
+    <div>
+      <h3>Project Type: {detection.types[0]?.name || 'Unknown'}</h3>
+      <p>Confidence: {detection.types[0]?.confidence}%</p>
+      <p>Size: {detection.size.name} ({detection.size.fileCount} files)</p>
+    </div>
+  );
+}
+```
+
+## Troubleshooting
+
+### Issue: No types detected
+
+**Possible causes:**
+- Project directory doesn't contain recognizable patterns
+- `package.json` or other key files missing
+- Directory is not a valid project
+
+**Solution:**
+- Check that project has standard structure (package.json, config files, etc.)
+- Verify directory path is correct
+- Try detecting a known project type first
+
+### Issue: Wrong type detected
+
+**Possible causes:**
+- Multiple project types in monorepo
+- Project has characteristics of multiple frameworks
+- Custom project structure
+
+**Solution:**
+- Check all detected types (sorted by confidence)
+- Use `isType()` with higher confidence threshold (e.g., 80%)
+- Consider the secondary types as well
+
+### Issue: Slow detection
+
+**Possible causes:**
+- Large project with many files
+- Not using git for file discovery
+- Scanning binary files or large assets
+
+**Solution:**
+- Ensure project is a git repository
+- Check `.gitignore` excludes `node_modules`, `dist`, etc.
+- Consider caching detection results for repeated scans
+
+## Next Steps
+
+After verifying the project detector works correctly:
+
+1. ✅ Test on BMAD Studio project (should detect Electron + React)
+2. ✅ Test on various project types (React, Vue, Angular, Node.js)
+3. ✅ Verify size categories are accurate
+4. ✅ Check performance meets targets
+5. 🔄 Integrate into Smart Adaptation features (subtask-8-2, 8-3, 8-4)
+6. 🔄 Add UI components for displaying detection results
+7. 🔄 Create project templates based on detected types
+
+---
+
+**Manual Verification Checklist:**
+
+- [ ] BMAD Studio detected as Electron + React
+- [ ] React project detected correctly
+- [ ] Vue project detected correctly (if available)
+- [ ] Size categories accurate
+- [ ] Analysis completes in < 5 seconds
+- [ ] Primary type matches expected
+- [ ] Confidence scores reasonable (>50% for correct types)