ai-flow-dev 2.6.0 → 2.8.0

package/prompts/desktop/flow-work.md

@@ -27,6 +27,88 @@ Provide a single, intelligent entry point for all development work (New Features
 
 ---
 
+## Phase -1: Intent Classification (PRE-DETECTION)
+
+**CRITICAL: Determine if this is an INFORMATIVE request vs EXECUTION request BEFORE any workflow.**
+
+**🔍 INFORMATIVE Patterns (Answer directly, NO execution workflow):**
+
+- **Questions:** Starts with `¿`, `how`, `why`, `what`, `when`, `cómo`, `por qué`, `qué`, `cuál`
+- **Analysis verbs:** `explain`, `show`, `list`, `analyze`, `describe`, `compare`, `explica`, `muestra`, `analiza`, `describe`, `compara`
+- **Report requests:** `report`, `informe`, `document`, `documenta`, `summary`, `resumen`, `generate report`, `genera informe`
+- **Exploration:** `find`, `search`, `busca`, `encuentra`, `where is`, `dónde está`
+- **Review requests:** `review`, `revisa`, `check`, `verifica`, `audit`, `audita`
+
+**🛠️ EXECUTION Patterns (Enter workflow):**
+
+- **Action verbs:** `implement`, `create`, `refactor`, `fix`, `add`, `remove`, `update`, `delete`, `build`, `develop`
+- **Task codes:** `HU-\d{3}-\d{3}`, `EP-\d{3}`, `T\d{3}`
+- **Imperative:** `new feature`, `nueva feature`, `crear`, `implementar`
+
+**Detection Logic:**
+
+```python
+import re
+
+# Normalize input
+input_lower = input.strip().lower()
+
+# INFORMATIVE patterns (high priority)
+informative_patterns = [
+    r'^(¿|how|why|what|when|where|cómo|por qué|qué|cuál|dónde)',
+    r'^(explain|show|list|analyze|describe|compare|explica|muestra|analiza|describe|compara)',
+    r'(report|informe|document|documenta|summary|resumen)',
+    r'(find|search|busca|encuentra)',
+    r'(review|revisa|check|verifica|audit|audita)',
+]
+
+for pattern in informative_patterns:
+    if re.search(pattern, input_lower):
+        return "INFORMATIVE"  # → Jump to Phase 99
+
+# EXECUTION patterns
+execution_patterns = [
+    r'(HU-\d{3}-\d{3}|EP-\d{3}|T\d{3})',  # Task codes
+    r'^(implement|create|refactor|fix|add|remove|update|delete|build|develop)',
+    r'(implementar|crear|nueva feature|new feature)',
+]
+
+for pattern in execution_patterns:
+    if re.search(pattern, input_lower):
+        return "EXECUTION"  # → Continue to Phase 0
+
+# Ambiguous case - ask user
+return "AMBIGUOUS"
+```
+
+**Action based on detection:**
+
+**IF mode == "INFORMATIVE":**
+
+```
+🔍 Detected: Informative request (question/report/analysis)
+
+I'll provide a detailed answer without creating work files or branches.
+```
+
+→ **Jump to Phase 99: Informative Response**
+
+**IF mode == "EXECUTION":**
+
+→ **Continue to Phase 0** (current workflow)
+
+**IF mode == "AMBIGUOUS":**
+
+```
+❓ I'm not sure if this is:
+  A) A question/report request (I'll answer directly)
+  B) A task to implement (I'll create work plan and execute)
+
+Please clarify (A/B): _
+```
+
+---
+
 ## Phase 0: Detection & Strategy (Automatic)
 
 **1. Semantic Analysis of Input:**
@@ -657,48 +739,9 @@ git status --porcelain
 - All checkboxes in work.md marked complete
 - User explicitly requests finalization
 
-**CRITICAL: This phase requires EXPLICIT user confirmations at each step.**
-
----
-
-### Step 1: Validation Check
-
-```
-🔍 Running validation...
-```
-
-Execute:
-
-```bash
-npm test  # or project-specific test command
-npm run lint  # or project-specific lint command
-```
-
-Show results:
-
-```
-📊 Validation Results
-
-Tests: [✅ Passed | ❌ Failed (N tests)]
-Lint: [✅ Clean | ⚠️ N warnings | ❌ N errors]
-Coverage: [X%]
-
-Proceed with finalization?
-
-a) Yes, continue ⭐
-b) No, let me fix issues
-c) Skip validation (not recommended)
-
-Your choice: _
-```
-
-- **'b'**: Return to Phase 3 for fixes, END finalization
-- **'c'**: Show warning, ask confirmation again, then continue
-- **'a'**: Continue to Step 2
-
 ---
 
-### Step 2: Source Documentation Update (Interactive)
+### Source Documentation Update (Interactive)
 
 **Detect source references:**
 
@@ -762,262 +805,398 @@ Your choice: _
 
 ---
 
-### Step 3: Archiving Decision (Explicit Confirmation)
+## ✅ Development Work Complete
 
-**Show current state:**
+Your code is ready for finalization. You have two options:
 
-```bash
-git diff --stat
-git log --oneline origin/[base-branch]..HEAD
-```
+### Option A: Run Full Finalization Now (Recommended) ⭐
 
-**Present archiving options:**
+Execute `/flow-finish` to complete all finalization steps automatically:
 
-```
-💾 Task Completion Options
+- ✅ **Smart Validation** - Runs tests + lint only if needed (or revalidates if requested)
+- 📦 **Work Archiving** - Records analytics to `.ai-flow/archive/analytics.jsonl`, cleans workspace
+- 🤖 **AI-Powered Summaries** - Generates professional PR/Jira descriptions (~1,200 tokens)
+- 🚀 **Optional Push** - Pushes to remote with explicit confirmation
 
-Current work:
-- Branch: [branch-name]
-- Files changed: [N]
-- Commits: [N]
-- Duration: [X min]
+**To proceed:** Type `/flow-finish` in the chat
 
-What do you want to do?
+---
 
-a) Complete & Archive ⭐
-   → Record analytics, delete work files, clean state
+### Option B: Manual Finalization
 
-b) Complete & Keep
-   → Record analytics, rename folder to [task]-completed
+If you prefer granular control over each step:
 
-c) Mark as Paused
-   → Keep work files for later resume
+1. **Validation:** `/flow-check` - Run comprehensive validation (tests + code review)
+2. **Commit:** `/flow-commit` - Create conventional commit with auto-generated message
+3. **Archive:** Manually record analytics and clean `.ai-flow/work/[task-name]/`
+4. **Push:** `git push origin [branch-name]` when ready
 
-d) Cancel
-   → Go back to editing
+---
+
+**What would you like to do?**
+
+```
+a) Run /flow-finish now ⭐ (Recommended - comprehensive automation)
+b) I'll handle finalization manually (granular control)
+c) Tell me more about what /flow-finish does
 
 Your choice: _
 ```
 
-**IF 'a' (Complete & Archive):**
-
-```
-✅ Archiving task...
-```
-
-1. **Extract metadata:**
-
-   ```javascript
-   // IF complexity == "COMPLEX" (has status.json):
-   analytics = {
-     task: '[task-name]',
-     type: '[feature|refactor|fix]',
-     src: '[HU-001-002|roadmap-2.3|manual]',
-     dur: Math.round((completed - created) / 60000), // minutes
-     start: timestamps.created,
-     end: new Date().toISOString(),
-     tasks: progress.totalTasks,
-     sp: extract_story_points_from_work_md(),
-     commits: git.commits.length,
-     valid: validation.tests.passed && validation.lint.passed,
-   };
-
-   // IF complexity == "MEDIUM" (only work.md):
-   analytics = {
-     task: '[task-name]',
-     type: '[detected-from-folder-name]',
-     src: 'manual',
-     dur: estimate_duration_from_git_log(),
-     start: get_first_commit_timestamp(),
-     end: new Date().toISOString(),
-     tasks: count_checkboxes_in_work_md(),
-     sp: extract_story_points_from_work_md() || null,
-     commits: count_commits_in_branch(),
-     valid: validation_passed,
-   };
-   ```
+**If 'a':** Execute `/flow-finish` immediately
 
-2. **Append to analytics:**
+**If 'b':** Show confirmation and end workflow:
 
-   ```bash
-   echo '{json}' >> .ai-flow/archive/analytics.jsonl
-   ```
+```
+✅ Understood. Development complete.
 
-3. **Delete work folder:**
+📋 Manual finalization checklist:
+- [ ] Run validation: /flow-check
+- [ ] Commit changes: /flow-commit
+- [ ] Archive work folder
+- [ ] Push to remote
+- [ ] Create PR/MR
 
-   ```bash
-   rm -rf .ai-flow/work/[task-name]/
-   ```
+💡 Tip: You can run /flow-finish anytime to automate these steps.
 
-4. **Show confirmation:**
+🎉 Great work!
+```
 
-   ```
-   ✅ Task archived successfully
+**If 'c':** Show detailed explanation:
 
-   📊 Analytics recorded:
-   - Duration: [X] min
-   - Story Points: [N]
-   - Commits: [N]
-   - Validation: [✅ Passed | ❌ Failed]
-   ```
+```
+📖 About /flow-finish
 
-**IF 'b' (Complete & Keep):**
+/flow-finish is an intelligent finalization workflow that:
 
-1. Record analytics (same as 'a')
-2. Rename folder:
-   ```bash
-   mv .ai-flow/work/[task] .ai-flow/work/[task]-completed/
-   ```
-3. Show: `✅ Task marked complete. Files kept in: .ai-flow/work/[task]-completed/`
+1️⃣ **Smart Validation (Step 1)**
+   - Detects if /flow-check was already run successfully
+   - Only re-runs if explicitly requested or validation failed
+   - Shows comprehensive test + lint results
 
-**IF 'c' (Mark as Paused):**
+2️⃣ **Smart Commit (Step 2)**
+   - Detects uncommitted changes automatically
+   - Runs /flow-commit only if needed
+   - Generates conventional commit messages
 
-1. Add marker file:
-   ```bash
-   echo "Paused: $(date)" > .ai-flow/work/[task]/PAUSED
-   ```
-2. Show: `⏸️ Task paused. Resume with: /flow-work`
-3. **END finalization**
+3️⃣ **Work Archiving (Step 3)**
+   - Extracts analytics: duration, story points, commits
+   - Appends to .ai-flow/archive/analytics.jsonl
+   - Deletes .ai-flow/work/[task-name]/ folder
 
-**IF 'd' (Cancel):**
+4️⃣ **AI Summaries (Step 4)**
+   - Reads git diff + commit history
+   - Generates professional PR description
+   - Generates ticket update (Jira/ClickUp/Linear)
+   - ~1,200 tokens, markdown-formatted
+
+5️⃣ **Optional Push (Step 5)**
+   - Always asks for confirmation
+   - Shows branch name and remote
+   - Never pushes without explicit approval
+
+**Would you like to run it now?** (y/n): _
+```
+
+**END WORKFLOW**
+
+---
+
+## Orchestration Rules
 
-1. Show: `❌ Finalization cancelled. Task remains active.`
-2. **END finalization**
+- **DRY Logic**: This file handles the high-level orchestration.
+- **Delegation**:
+  - Detailed Feature logic → `@flow-work-feature.md`
+  - Detailed Refactor logic → `@flow-work-refactor.md`
+  - Detailed Fix logic → `@flow-work-fix.md`
+  - Resume logic → `@flow-work-resume.md`
+- **State Persistence**: Always read/write to `.ai-flow/work/[name]/status.json` to maintain state across sessions.
 
 ---
 
-### Step 4: Ticket Summary (Optional)
+## Phase 99: Informative Response
 
-**Only ask if task was archived (option 'a' or 'b'):**
+**This phase handles questions, reports, and analysis requests WITHOUT creating work files or branches.**
 
-```
-📋 Generate ticket summary?
+### 1. Analyze Request Type
 
-(For ClickUp, Jira, Linear, Asana, Trello, GitHub Projects, etc.)
+**Classify the informative request:**
 
-y/n: _
-```
+- **Technical Question:** How does X work? Why do we use Y?
+- **UI Component Explanation:** Explain this window/panel/dialog
+- **Architecture Review:** Show me the application structure/threading model
+- **Project Report:** Generate report on dependencies/JAR size/test coverage
+- **File Location:** Where is X class? Find Y service
+- **Comparison:** Compare Swing vs JavaFX approach
+- **Best Practices:** What's the best way to handle X in desktop apps?
 
-**IF 'y':**
+### 2. Load Relevant Context
 
-1. Check if template exists:
+**Based on request type, load specific documentation:**
 
-   ```bash
-   [ -f .ai-flow/prompts/shared/task-summary-template.md ]
-   ```
+**IF question about architecture/patterns:**
 
-2. **IF template exists:**
-   - Read template
-   - Extract data from:
-     - Last line of `analytics.jsonl`
-     - Git stats: `git diff --stat`, `git log --oneline`
-     - Branch info
-   - Populate template with real data
-   - Show formatted summary
+- Read `ai-instructions.md` (NEVER/ALWAYS rules)
+- Read `docs/architecture.md` (MVC/MVP/MVVM, threading, layers)
+- Search codebase for examples
 
-3. **IF template doesn't exist:**
-   - Generate basic summary:
+**IF question about specific component:**
 
-   ```
-   📋 Task Summary
+- Search codebase for class/form files
+- Read relevant specs from `specs/`
+- Check UI thread handling
 
-   **Task**: [task-name]
-   **Type**: [feature|refactor|fix]
-   **Duration**: [X min]
-   **Story Points**: [N]
-   **Commits**: [N]
-   **Branch**: [branch-name]
-   **Status**: ✅ Complete
+**IF report request:**
 
-   **Changes**:
-   [git diff --stat output]
+- Run appropriate analysis (JAR size, dependencies, coverage)
+- Read relevant docs for context
+- Generate structured report
 
-   **Commits**:
-   [git log --oneline output]
-   ```
+**IF file location request:**
 
-4. Show: `📋 Copy the summary above to your ticket system`
+- Search codebase with grep/semantic search
+- List relevant classes with descriptions
 
-**IF 'n':**
+### 3. Provide Comprehensive Answer
 
-```
-⏭️ Skipping ticket summary
-```
+**Structure your response:**
 
----
+```markdown
+## [Question/Request]
 
-### Step 5: Git Push (Final Step)
+### Answer
 
-```
-🚀 Push changes to remote?
+[Detailed explanation with code examples if relevant]
+
+### Related Documentation
+
+- [Link to relevant docs]
+- [Link to class/component examples]
 
-git push origin [branch-name]
+### Additional Context
 
-y/n: _
+[Architecture decisions, threading considerations, platform differences]
+
+### Related User Stories/Features
+
+[If applicable, link to planning docs]
 ```
 
-**IF 'y':**
+**Guidelines:**
+
+- **Be comprehensive:** Load all relevant context, don't guess
+- **Show examples:** Include actual code from the project
+- **Reference docs:** Link to `docs/`, `specs/`, `planning/`
+- **Explain trade-offs:** Why was Swing chosen over JavaFX?
+- **Threading safety:** Highlight EDT/Platform.runLater usage
+- **Provide sources:** Always cite where information comes from
+
+### 4. Offer Follow-up Actions
+
+**After answering, offer next steps:**
 
-```bash
-git push origin [branch-name]
 ```
+✅ Answer provided.
 
-Show result:
+Would you like me to:
+  A) Implement changes based on this analysis
+  B) Create a work plan for improvements
+  C) Generate a spec/doc for this
+  D) Nothing, just the answer
 
+Your choice (or just ask another question): _
 ```
-✅ Pushed to origin/[branch-name]
 
-Next steps:
-- Create Pull Request/Merge Request
-- Request code review
-- Update project board
+**IF user chooses A or B:**
+
+- Return to Phase 0 with refined objective
+- Create appropriate work.md and proceed with execution
+
+**IF user chooses C:**
+
+- Create spec/doc file in appropriate location
+- Commit with descriptive message
+
+**IF user chooses D or asks another question:**
+
+- **END WORKFLOW** (no files created, no branches)
+
+### 5. Example Interactions
+
+**Example 1: Technical Question**
+
+````
+User: /flow-work ¿cómo funciona el threading model en Swing?
+
+Agent:
+🔍 Detected: Informative request (question)
+
+## How Threading Works in This Desktop Application
+
+### Swing Threading Model
+
+Our application follows Swing's single-threaded model:
+- **EDT (Event Dispatch Thread):** All UI updates
+- **Worker Threads:** Background tasks (DB, network, file I/O)
+
+### Implementation Pattern
+
+```java
+// Example from UserService.java
+public void loadUsersAsync(Consumer<List<User>> callback) {
+    // Background thread for DB query
+    SwingWorker<List<User>, Void> worker = new SwingWorker<>() {
+        @Override
+        protected List<User> doInBackground() throws Exception {
+            return userRepository.findAll(); // Runs on worker thread
+        }
+
+        @Override
+        protected void done() {
+            try {
+                List<User> users = get();
+                SwingUtilities.invokeLater(() -> {
+                    callback.accept(users); // Update UI on EDT
+                });
+            } catch (Exception e) {
+                handleError(e);
+            }
+        }
+    };
+    worker.execute();
+}
+````
+
+### Key Rules in This Project
+
+1. **NEVER block EDT:** All long operations use SwingWorker
+2. **ALWAYS update UI on EDT:** Use `SwingUtilities.invokeLater()`
+3. **Use SwingWorker for progress:** `publish()` and `process()` for updates
+
+### Common Patterns
+
+```java
+// Pattern 1: Simple async task
+SwingUtilities.invokeLater(() -> {
+    label.setText("Updated"); // Safe: runs on EDT
+});
+
+// Pattern 2: Background with progress
+SwingWorker<Result, Integer> worker = new SwingWorker<>() {
+    @Override
+    protected Result doInBackground() {
+        for (int i = 0; i < 100; i++) {
+            // Long operation
+            publish(i); // Report progress
+        }
+        return result;
+    }
+
+    @Override
+    protected void process(List<Integer> chunks) {
+        progressBar.setValue(chunks.get(chunks.size() - 1));
+    }
+};
 ```
 
-**IF 'n':**
+### Where to Find Examples
+
+- `src/services/UserService.java` - Database operations
+- `src/ui/MainWindow.java` - File loading
+- `src/ui/ReportDialog.java` - Report generation
+
+### Related Documentation
+
+- `ai-instructions.md` - Threading rules (NEVER block EDT)
+- `docs/architecture.md` - Service layer patterns
+
+Would you like me to review other classes for threading issues? (Y/N): \_
 
 ```
-⏭️ Skipping push
 
-⚠️ Remember to push later:
-   git push origin [branch-name]
+**Example 2: Report Request**
+
 ```
 
----
+User: /flow-work genera un informe de dependencias del proyecto
 
-### Finalization Complete
+Agent:
+🔍 Detected: Informative request (report)
 
-```
-✅ Task Finalization Complete
+## Project Dependencies Report
 
-📊 Summary:
-- [✅|⚠️] Validation passed
-- [✅|⏭️] Documentation updated
-- [✅|⏭️] Task archived
-- [✅|⏭️] Ticket summary generated
-- [✅|⏭️] Pushed to remote
+[Analyzes pom.xml/build.gradle]
 
-Task: [task-name]
-Branch: [branch-name]
-Duration: [X min]
-Commits: [N]
+### Build System: Maven
 
-🎉 Great work!
+### Java Version: 17
+
+### Total Dependencies: 18 (12 compile, 6 test)
+
+#### Core Dependencies
+
+| Dependency          | Version | Scope   | Size   | Purpose            |
+| ------------------- | ------- | ------- | ------ | ------------------ |
+| H2 Database         | 2.1.214 | runtime | 2.3 MB | Embedded database  |
+| FlatLaf             | 3.2.1   | compile | 1.1 MB | Modern Look & Feel |
+| Jackson Databind    | 2.15.2  | compile | 1.5 MB | JSON processing    |
+| SLF4J + Logback     | 2.0.9   | compile | 800 KB | Logging            |
+| Apache Commons Lang | 3.13.0  | compile | 640 KB | Utilities          |
+| Apache Commons IO   | 2.13.0  | compile | 510 KB | File operations    |
+
+#### Test Dependencies
+
+| Dependency    | Version | Scope | Purpose           |
+| ------------- | ------- | ----- | ----------------- |
+| JUnit Jupiter | 5.10.0  | test  | Unit testing      |
+| AssertJ Core  | 3.24.2  | test  | Fluent assertions |
+| AssertJ Swing | 3.17.1  | test  | UI testing        |
+| Mockito       | 5.5.0   | test  | Mocking           |
+
+### JAR Size Analysis
+
+- Application JAR: 450 KB
+- Dependencies: ~8 MB
+- **Total**: ~8.5 MB
+
+### Dependency Tree
+
+```
+com.example.app:1.0.0
+├── H2 Database:2.1.214
+├── FlatLaf:3.2.1
+│   └── FlatLaf Core (transitive)
+├── Jackson Databind:2.15.2
+│   ├── Jackson Core (transitive)
+│   └── Jackson Annotations (transitive)
+└── Logback:1.4.11
+    └── SLF4J API (transitive)
 ```
 
-**END WORKFLOW**
+### Security Report
 
----
+✅ No known vulnerabilities (checked against CVE database)
 
-## Orchestration Rules
+### Recommendations
 
-- **DRY Logic**: This file handles the high-level orchestration.
-- **Delegation**:
-  - Detailed Feature logic → `@flow-work-feature.md`
-  - Detailed Refactor logic → `@flow-work-refactor.md`
-  - Detailed Fix logic → `@flow-work-fix.md`
-  - Resume logic → `@flow-work-resume.md`
-- **State Persistence**: Always read/write to `.ai-flow/work/[name]/status.json` to maintain state across sessions.
+1. ✅ All dependencies up to date
+2. ✅ No deprecated libraries
+3. 💡 Consider ProGuard/R8 for distribution (reduce size by ~40%)
+4. 💡 H2 database could be replaced with SQLite (smaller: 1.2 MB)
+
+### License Compliance
+
+- Apache 2.0: 14 dependencies ✅
+- MIT: 3 dependencies ✅
+- EPL 2.0: 1 dependency (H2) ✅
+
+All licenses compatible with commercial use.
+
+Would you like me to create a plan to reduce bundle size? (Y/N): \_
+
+```
 
 ---
 
 **BEGIN EXECUTION when user runs `/flow-work [args]`**
+```