ai-flow-dev 2.7.0 → 2.8.1

package/prompts/desktop/flow-build-phase-3.md

@@ -1,291 +1,291 @@
-## PHASE 3: Architecture Desktop (15-20 min)
-
-> **Order for this phase:** 3.1 → 3.2 → 3.3 → 3.4 → 3.5 → 3.6
-
-### Objective
-
-Define the application architecture, design patterns, and code organization for desktop applications.
-
----
-
-## 3.1 Architecture Pattern
-
-```
-Which architectural pattern will you use?
-
-A) 🏗️ MVC (Model-View-Controller) - Classic separation
-   - Model: Data and business logic
-   - View: UI components (Swing/JavaFX/SWT)
-   - Controller: Event handling and coordination
-   - Best for: Traditional desktop apps
-
-B) 📱 MVP (Model-View-Presenter) - Testable UI
-   - Model: Data layer
-   - View: Passive UI interface
-   - Presenter: UI logic and testing
-   - Best for: Apps requiring extensive UI testing
-
-C) 🎨 MVVM (Model-View-ViewModel) - Data binding
-   - Model: Data entities
-   - View: UI (FXML, declarative)
-   - ViewModel: Observable properties
-   - Best for: JavaFX with property binding
-
-D) 🏛️ Layered Architecture - Classic N-tier
-   - Presentation Layer (UI)
-   - Business Logic Layer (Services)
-   - Data Access Layer (DAO/Repository)
-   - Best for: Enterprise applications
-
-E) 🔌 Plugin Architecture - Extensible
-   - Core application + plugin system
-   - Plugins loaded dynamically
-   - Best for: IDEs, tools with extensions
-
-F) 🎯 Event-Driven - Reactive
-   - Components communicate via events
-   - EventBus or Observer pattern
-   - Best for: Loosely coupled components
-
-Your choice: __
-```
-
----
-
-## 3.2 Package Structure
-
-```
-How will you organize your code packages?
-
-**Classic Structure (MVC/MVP):**
-```
-
-com.company.appname/
-├── model/ # Data entities
-│ ├── User.java
-│ └── Project.java
-├── view/ # UI components
-│ ├── MainWindow.java
-│ └── dialogs/
-├── controller/ # Controllers/Presenters
-│ ├── MainController.java
-│ └── LoginController.java
-├── service/ # Business logic
-│ ├── UserService.java
-│ └── ProjectService.java
-├── dao/ # Data access
-│ ├── UserDAO.java
-│ └── ProjectDAO.java
-└── util/ # Utilities
-├── DateUtil.java
-└── FileUtil.java
-
-```
-
-**JavaFX Structure (MVVM):**
-```
-
-com.company.appname/
-├── model/ # Data models
-├── view/ # FXML files (in resources/)
-├── viewmodel/ # ViewModels with properties
-├── controller/ # FXML controllers
-├── service/ # Business services
-└── repository/ # Data repositories
-
-```
-
-**Plugin Structure:**
-```
-
-com.company.appname/
-├── core/ # Core application
-│ ├── Application.java
-│ └── PluginManager.java
-├── plugin/ # Plugin API
-│ └── IPlugin.java
-├── plugins/ # Plugin implementations
-│ ├── pdf/
-│ └── excel/
-├── ui/ # UI components
-└── service/ # Core services
-
-```
-
-Which structure fits your needs? (Or describe custom):
-__
-```
-
----
-
-## 3.3 Threading Model
-
-```
-Desktop applications must handle UI responsiveness. How will you manage threading?
-
-**UI Thread (Event Dispatch Thread):**
-- Swing: SwingUtilities.invokeLater()
-- JavaFX: Platform.runLater()
-- SWT: Display.asyncExec()
-
-**Background Tasks:**
-A) SwingWorker (Swing) - Background task with progress
-B) Task/Service (JavaFX) - JavaFX background tasks
-C) ExecutorService - Custom thread pools
-D) CompletableFuture - Async operations (Java 8+)
-E) Virtual Threads - Project Loom (Java 21+)
-
-Your threading strategy:
-A) ✅ All long-running operations in background threads
-B) 🔄 Progress indicators for tasks > 1 second
-C) ❌ Blocking UI (not recommended)
-
-Concurrency patterns:
-A) Producer-Consumer (queue-based)
-B) Future/Promise (async results)
-C) Observer (event notifications)
-D) Synchronized collections
-
-Your choices: __
-```
-
----
-
-## 3.4 Event Handling
-
-```
-How will components communicate?
-
-**Swing Event Handling:**
-A) ActionListener - Button clicks
-B) DocumentListener - Text changes
-C) PropertyChangeListener - Property changes
-D) Custom EventListener - Domain events
-
-**JavaFX Event Handling:**
-A) EventHandler<ActionEvent> - Button clicks
-B) ChangeListener - Observable property changes
-C) InvalidationListener - Observable invalidation
-D) Custom events with EventBus
-
-**SWT Event Handling:**
-A) SelectionListener - Widget selections
-B) ModifyListener - Text modifications
-C) FocusListener - Focus changes
-D) Custom events
-
-**Event Bus Libraries:**
-A) EventBus (Guava) - Simple pub/sub
-B) MBassador - High-performance event bus
-C) Custom Observer pattern
-
-Your event strategy: __
-```
-
----
-
-## 3.5 Dependency Injection
-
-```
-Will you use Dependency Injection?
-
-A) ✅ Yes - Framework-based
-   - Spring Framework (Desktop edition)
-   - Google Guice
-   - CDI (Weld SE)
-
-B) ✅ Yes - Manual
-   - Constructor injection
-   - Factory pattern
-   - Service locator
-
-C) ❌ No - Direct instantiation
-   - new MyService()
-   - Singleton pattern
-
-Your choice: __
-
-If yes, how will you manage dependencies?
-- Scopes: Singleton, Prototype
-- Lifecycle: Initialization, cleanup
-- Configuration: Annotations vs XML
-```
-
----
-
-## 3.6 Error Handling
-
-```
-How will you handle errors and exceptions?
-
-**Global Exception Handler:**
-A) ✅ Yes - Catch all uncaught exceptions
-   - Swing: Thread.setDefaultUncaughtExceptionHandler()
-   - JavaFX: Thread.setDefaultUncaughtExceptionHandler()
-   - Show error dialog to user
-   - Log to file
-
-B) ❌ No - Handle locally
-
-**Error Dialog Strategy:**
-A) 🔴 Error Dialog - Show details, allow reporting
-B) 🎨 Toast Notification - Non-intrusive for minor errors
-C) 📝 Status Bar - Show error message
-D) 📋 Log only - Silent errors, check logs
-
-**Logging:**
-A) SLF4J + Logback - Industry standard
-B) Log4j2 - Apache logging
-C) java.util.logging - Built-in
-D) Custom logging
-
-Log levels:
-- TRACE - Detailed debug
-- DEBUG - Development info
-- INFO - General info
-- WARN - Warning messages
-- ERROR - Error messages
-
-Your choices: __
-```
-
----
-
-### Phase 3 Output
-
-```
-📋 PHASE 3 SUMMARY:
-
-Architecture Pattern: [MVC/MVP/MVVM/Layered/Plugin/Event-Driven]
-Package Structure: [Described above]
-Threading Model: [SwingWorker, Task, ExecutorService]
-Event Handling: [ActionListener, EventBus, etc.]
-Dependency Injection: [Spring/Guice/Manual/None]
-Error Handling: [Global handler, error dialogs, logging strategy]
-
-Is this correct? (Yes/No)
-```
-
----
-
-### 📄 Update Documents
-
-Update `docs/ARCHITECTURE.md` with:
-
-- Architecture pattern diagram
-- Package structure
-- Threading model and best practices
-- Event handling flow
-- Dependency injection configuration
-- Error handling strategy
-
----
-
-**Next Phase:** Phase 4 - Data & Storage (15-20 min)
-
-Read: `.ai-flow/prompts/desktop/flow-build-phase-4.md`
-
----
-
-**Last Updated:** 2025-02-03
-**Version:** 1.0.0
+## PHASE 3: Architecture Desktop (15-20 min)
+
+> **Order for this phase:** 3.1 → 3.2 → 3.3 → 3.4 → 3.5 → 3.6
+
+### Objective
+
+Define the application architecture, design patterns, and code organization for desktop applications.
+
+---
+
+## 3.1 Architecture Pattern
+
+```
+Which architectural pattern will you use?
+
+A) 🏗️ MVC (Model-View-Controller) - Classic separation
+   - Model: Data and business logic
+   - View: UI components (Swing/JavaFX/SWT)
+   - Controller: Event handling and coordination
+   - Best for: Traditional desktop apps
+
+B) 📱 MVP (Model-View-Presenter) - Testable UI
+   - Model: Data layer
+   - View: Passive UI interface
+   - Presenter: UI logic and testing
+   - Best for: Apps requiring extensive UI testing
+
+C) 🎨 MVVM (Model-View-ViewModel) - Data binding
+   - Model: Data entities
+   - View: UI (FXML, declarative)
+   - ViewModel: Observable properties
+   - Best for: JavaFX with property binding
+
+D) 🏛️ Layered Architecture - Classic N-tier
+   - Presentation Layer (UI)
+   - Business Logic Layer (Services)
+   - Data Access Layer (DAO/Repository)
+   - Best for: Enterprise applications
+
+E) 🔌 Plugin Architecture - Extensible
+   - Core application + plugin system
+   - Plugins loaded dynamically
+   - Best for: IDEs, tools with extensions
+
+F) 🎯 Event-Driven - Reactive
+   - Components communicate via events
+   - EventBus or Observer pattern
+   - Best for: Loosely coupled components
+
+Your choice: __
+```
+
+---
+
+## 3.2 Package Structure
+
+```
+How will you organize your code packages?
+
+**Classic Structure (MVC/MVP):**
+```
+
+com.company.appname/
+├── model/ # Data entities
+│ ├── User.java
+│ └── Project.java
+├── view/ # UI components
+│ ├── MainWindow.java
+│ └── dialogs/
+├── controller/ # Controllers/Presenters
+│ ├── MainController.java
+│ └── LoginController.java
+├── service/ # Business logic
+│ ├── UserService.java
+│ └── ProjectService.java
+├── dao/ # Data access
+│ ├── UserDAO.java
+│ └── ProjectDAO.java
+└── util/ # Utilities
+├── DateUtil.java
+└── FileUtil.java
+
+```
+
+**JavaFX Structure (MVVM):**
+```
+
+com.company.appname/
+├── model/ # Data models
+├── view/ # FXML files (in resources/)
+├── viewmodel/ # ViewModels with properties
+├── controller/ # FXML controllers
+├── service/ # Business services
+└── repository/ # Data repositories
+
+```
+
+**Plugin Structure:**
+```
+
+com.company.appname/
+├── core/ # Core application
+│ ├── Application.java
+│ └── PluginManager.java
+├── plugin/ # Plugin API
+│ └── IPlugin.java
+├── plugins/ # Plugin implementations
+│ ├── pdf/
+│ └── excel/
+├── ui/ # UI components
+└── service/ # Core services
+
+```
+
+Which structure fits your needs? (Or describe custom):
+__
+```
+
+---
+
+## 3.3 Threading Model
+
+```
+Desktop applications must handle UI responsiveness. How will you manage threading?
+
+**UI Thread (Event Dispatch Thread):**
+- Swing: SwingUtilities.invokeLater()
+- JavaFX: Platform.runLater()
+- SWT: Display.asyncExec()
+
+**Background Tasks:**
+A) SwingWorker (Swing) - Background task with progress
+B) Task/Service (JavaFX) - JavaFX background tasks
+C) ExecutorService - Custom thread pools
+D) CompletableFuture - Async operations (Java 8+)
+E) Virtual Threads - Project Loom (Java 21+)
+
+Your threading strategy:
+A) ✅ All long-running operations in background threads
+B) 🔄 Progress indicators for tasks > 1 second
+C) ❌ Blocking UI (not recommended)
+
+Concurrency patterns:
+A) Producer-Consumer (queue-based)
+B) Future/Promise (async results)
+C) Observer (event notifications)
+D) Synchronized collections
+
+Your choices: __
+```
+
+---
+
+## 3.4 Event Handling
+
+```
+How will components communicate?
+
+**Swing Event Handling:**
+A) ActionListener - Button clicks
+B) DocumentListener - Text changes
+C) PropertyChangeListener - Property changes
+D) Custom EventListener - Domain events
+
+**JavaFX Event Handling:**
+A) EventHandler<ActionEvent> - Button clicks
+B) ChangeListener - Observable property changes
+C) InvalidationListener - Observable invalidation
+D) Custom events with EventBus
+
+**SWT Event Handling:**
+A) SelectionListener - Widget selections
+B) ModifyListener - Text modifications
+C) FocusListener - Focus changes
+D) Custom events
+
+**Event Bus Libraries:**
+A) EventBus (Guava) - Simple pub/sub
+B) MBassador - High-performance event bus
+C) Custom Observer pattern
+
+Your event strategy: __
+```
+
+---
+
+## 3.5 Dependency Injection
+
+```
+Will you use Dependency Injection?
+
+A) ✅ Yes - Framework-based
+   - Spring Framework (Desktop edition)
+   - Google Guice
+   - CDI (Weld SE)
+
+B) ✅ Yes - Manual
+   - Constructor injection
+   - Factory pattern
+   - Service locator
+
+C) ❌ No - Direct instantiation
+   - new MyService()
+   - Singleton pattern
+
+Your choice: __
+
+If yes, how will you manage dependencies?
+- Scopes: Singleton, Prototype
+- Lifecycle: Initialization, cleanup
+- Configuration: Annotations vs XML
+```
+
+---
+
+## 3.6 Error Handling
+
+```
+How will you handle errors and exceptions?
+
+**Global Exception Handler:**
+A) ✅ Yes - Catch all uncaught exceptions
+   - Swing: Thread.setDefaultUncaughtExceptionHandler()
+   - JavaFX: Thread.setDefaultUncaughtExceptionHandler()
+   - Show error dialog to user
+   - Log to file
+
+B) ❌ No - Handle locally
+
+**Error Dialog Strategy:**
+A) 🔴 Error Dialog - Show details, allow reporting
+B) 🎨 Toast Notification - Non-intrusive for minor errors
+C) 📝 Status Bar - Show error message
+D) 📋 Log only - Silent errors, check logs
+
+**Logging:**
+A) SLF4J + Logback - Industry standard
+B) Log4j2 - Apache logging
+C) java.util.logging - Built-in
+D) Custom logging
+
+Log levels:
+- TRACE - Detailed debug
+- DEBUG - Development info
+- INFO - General info
+- WARN - Warning messages
+- ERROR - Error messages
+
+Your choices: __
+```
+
+---
+
+### Phase 3 Output
+
+```
+📋 PHASE 3 SUMMARY:
+
+Architecture Pattern: [MVC/MVP/MVVM/Layered/Plugin/Event-Driven]
+Package Structure: [Described above]
+Threading Model: [SwingWorker, Task, ExecutorService]
+Event Handling: [ActionListener, EventBus, etc.]
+Dependency Injection: [Spring/Guice/Manual/None]
+Error Handling: [Global handler, error dialogs, logging strategy]
+
+Is this correct? (Yes/No)
+```
+
+---
+
+### 📄 Update Documents
+
+Update `docs/ARCHITECTURE.md` with:
+
+- Architecture pattern diagram
+- Package structure
+- Threading model and best practices
+- Event handling flow
+- Dependency injection configuration
+- Error handling strategy
+
+---
+
+**Next Phase:** Phase 4 - Data & Storage (15-20 min)
+
+Read: `.ai-flow/prompts/desktop/flow-build-phase-4.md`
+
+---
+
+**Last Updated:** 2025-02-03
+**Version:** 1.0.0