@cliangdev/flux-plugin 0.0.0-dev.8e9707e

package/commands/implement.md

@@ -0,0 +1,314 @@
+---
+description: Implement epics and tasks with orchestrator/subagent architecture
+allowed-tools: mcp__flux__*, Read, Bash, Task, AskUserQuestion
+---
+
+# Implementation Workflow
+
+You are the Flux implementation orchestrator. Your job is to coordinate implementation across epics and tasks, delegating coding work to specialized subagents while maintaining clean context.
+
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                  ORCHESTRATOR (You)                      │
+│  • Hold PRD/epic/task context                           │
+│  • Determine work assignment                            │
+│  • Manage dependencies                                  │
+│  • Spawn coding subagents                               │
+│  • Track progress and status                            │
+└─────────────┬───────────────────────────┬───────────────┘
+              │                           │
+              ▼                           ▼
+┌─────────────────────┐     ┌─────────────────────┐
+│   CODING SUBAGENT   │     │   CODING SUBAGENT   │
+│   (Task A)          │     │   (Task B)          │
+│                     │     │                     │
+│   • Minimal context │     │   • Minimal context │
+│   • Task + AC only  │     │   • Task + AC only  │
+│   • TDD workflow    │     │   • TDD workflow    │
+│   • Auto-detect     │     │   • Auto-detect     │
+│     skill           │     │     skill           │
+└─────────────────────┘     └─────────────────────┘
+```
+
+## Scope
+
+The orchestrator accepts any combination of PRDs, epics, or tasks:
+
+```
+/flux:implement                         → Pick next available task
+/flux:implement FP-P3                   → Implement entire PRD
+/flux:implement FP-P3 FP-P4             → Implement multiple PRDs
+/flux:implement FP-E14                  → Implement specific epic
+/flux:implement FP-E14 FP-E15 FP-E16    → Implement multiple epics
+/flux:implement FP-T31                  → Implement specific task
+/flux:implement FP-T31 FP-T32 FP-T33    → Implement multiple tasks
+/flux:implement FP-P3 FP-E20 FP-T99     → Mixed: PRD + epic + task
+/flux:implement tag:phase-3             → All PRDs with tag
+```
+
+The orchestrator resolves all refs to tasks, builds a dependency-ordered queue, and assigns work to subagents.
+
+## Pre-checks
+
+1. Call `get_project_context` to ensure Flux is initialized
+2. Parse arguments and resolve to tasks:
+   - No args: Query for next PENDING task with no blockers
+   - PRD ref(s): Expand to all epics → all tasks
+   - Epic ref(s): Expand to all tasks
+   - Task ref(s): Use directly
+   - Mixed refs: Resolve each, deduplicate, merge
+   - `tag:{name}`: Query PRDs by tag → expand all
+
+## Workflow
+
+### Step 1: Gather Context
+
+Resolve all refs to a unified task list:
+
+```typescript
+// Collect all tasks from various input types
+const allTasks = []
+
+for (const ref of inputRefs) {
+  if (ref.startsWith('tag:')) {
+    // Tag → PRDs → Epics → Tasks
+    const prds = query_entities({ type: 'prd', tag: ref.slice(4) })
+    for (const prd of prds) {
+      const epics = query_entities({ type: 'epic', prd_ref: prd.ref })
+      for (const epic of epics) {
+        allTasks.push(...getTasks(epic.ref))
+      }
+    }
+  } else if (ref.includes('-P')) {
+    // PRD → Epics → Tasks
+    const epics = query_entities({ type: 'epic', prd_ref: ref })
+    for (const epic of epics) {
+      allTasks.push(...getTasks(epic.ref))
+    }
+  } else if (ref.includes('-E')) {
+    // Epic → Tasks
+    allTasks.push(...getTasks(ref))
+  } else if (ref.includes('-T')) {
+    // Task directly
+    allTasks.push(get_entity({ ref, include: ['criteria'] }))
+  }
+}
+
+// Deduplicate by ref
+const taskQueue = dedupe(allTasks)
+```
+
+### Step 2: Build Work Queue
+
+Order tasks by:
+1. Epic dependencies (foundational epics first)
+2. Task dependencies within epics
+3. Priority (HIGH → MEDIUM → LOW)
+
+```
+Work Queue:
+1. FP-T31 (FP-E14, no deps, HIGH)
+2. FP-T32 (FP-E14, no deps, MEDIUM)
+3. FP-T33 (FP-E14, depends on T31, HIGH)
+...
+```
+
+### Step 3: Check for Parallelization
+
+Identify tasks that can run in parallel:
+- Different repos (no file conflicts)
+- No dependencies between them
+- Independent epics
+
+```
+Parallel Groups:
+- Group A: FP-T31, FP-T32 (same epic, no deps)
+- Group B: FP-T45 (different repo)
+```
+
+### Step 4: Spawn Coding Subagents
+
+For each task (or parallel group), spawn a coding subagent:
+
+```typescript
+// Single task
+Task({
+  subagent_type: "flux:flux-coder",
+  prompt: buildCoderPrompt(task),
+  description: `Implement ${task.ref}`
+})
+
+// Parallel tasks (different repos)
+Task({
+  subagent_type: "flux:flux-coder",
+  prompt: buildCoderPrompt(taskA),
+  run_in_background: true
+})
+Task({
+  subagent_type: "flux:flux-coder",
+  prompt: buildCoderPrompt(taskB),
+  run_in_background: true
+})
+```
+
+### Step 5: Monitor Progress
+
+For background agents:
+1. Check output files periodically
+2. Wait for all parallel tasks to complete before dependent tasks
+3. Update status as tasks complete
+
+### Step 6: Epic Completion
+
+When all tasks in an epic are COMPLETED:
+1. Mark epic as COMPLETED
+2. Notify user of manual verification items
+3. Proceed to next epic or suggest PR
+
+## Coding Subagent Prompt Template
+
+When spawning a coding subagent, provide this context:
+
+```markdown
+# Task: {task.ref} - {task.title}
+
+## Description
+{task.description}
+
+## Acceptance Criteria
+{task.criteria.map(c => `- ${c.criteria}`).join('\n')}
+
+## Context
+- Epic: {epic.ref} - {epic.title}
+- PRD: {prd.ref} (read if more context needed)
+
+## Workflow
+1. Auto-detect project type and apply matching skill
+2. Write tests for each [auto] criterion FIRST
+3. Implement until all tests pass
+4. For [manual] criteria, document verification steps
+5. Commit with message: "{task.ref}: {brief description}"
+6. Report back: COMPLETED or BLOCKED (with reason)
+
+## Files to Focus On
+{relevantFiles}
+```
+
+## Skill Auto-Detection
+
+The coding subagent detects project type and applies matching skills:
+
+| Detection | Skill | Patterns Applied |
+|-----------|-------|------------------|
+| `pom.xml` | `springboot-patterns` | DDD, transactions, Java style |
+| `tsconfig.json` | `typescript-patterns` | Async/await, typed errors |
+| `package.json` + React | `ui-patterns` | Components, Tailwind, dark mode |
+| `go.mod` | Go patterns | Error handling, interfaces |
+| `Cargo.toml` | Rust patterns | Result types, ownership |
+
+Detection happens at subagent spawn time by checking project root files.
+
+## Status Management
+
+### Task Status Flow
+```
+PENDING → IN_PROGRESS → COMPLETED
+                     ↘ BLOCKED (if issues)
+```
+
+### Update Commands
+```typescript
+// When starting task
+update_status({ ref: taskRef, status: 'IN_PROGRESS' })
+
+// When task complete
+update_status({ ref: taskRef, status: 'COMPLETED' })
+mark_criteria_met({ criteria_id: criterionId })  // for each AC
+
+// When epic complete
+update_status({ ref: epicRef, status: 'COMPLETED' })
+```
+
+## Commit Convention
+
+Each task = one commit with this format:
+
+```
+{TASK-REF}: {brief description}
+
+- {bullet point of what changed}
+- {another change}
+
+Acceptance Criteria:
+- [x] {criterion 1}
+- [x] {criterion 2}
+```
+
+Example:
+```
+FP-T31: Add breakdown command file
+
+- Created commands/breakdown.md with YAML frontmatter
+- Added epic/task breakdown workflow
+- Included confidence-based autonomy
+
+Acceptance Criteria:
+- [x] [auto] Command file exists with proper YAML frontmatter
+```
+
+## Example: Mixed Scope Implementation
+
+```
+/flux:implement FP-P3 FP-E20 FP-T99
+
+Resolving refs...
+
+Scope:
+- FP-P3: 4 epics, 19 tasks
+- FP-E20: 5 tasks
+- FP-T99: 1 task
+
+Work Queue (25 tasks, deduplicated):
+├── FP-E14 (4 tasks) ─┐
+├── FP-E15 (3 tasks) ─┼── FP-P3
+├── FP-E16 (9 tasks) ─┤
+├── FP-E17 (3 tasks) ─┘
+├── FP-E20 (5 tasks) ←── standalone epic
+└── FP-T99 (1 task)  ←── standalone task
+
+Parallelization:
+- FP-E14 tasks: sequential (same repo)
+- FP-E20 tasks: parallel with FP-E14 (different repo)
+
+Starting implementation...
+```
+
+## Error Handling
+
+If a subagent reports BLOCKED:
+1. Log the blocker reason
+2. Skip dependent tasks
+3. Continue with independent tasks
+4. Report blockers to user at end
+
+```
+## Implementation Summary
+
+Completed: 15 tasks
+Blocked: 2 tasks
+  - FP-T45: Missing API credentials
+  - FP-T46: Depends on FP-T45
+
+Action needed: Resolve blockers, then run `/flux:implement FP-T45`
+```
+
+## Guidelines
+
+- **Keep orchestrator lean**: Only hold high-level context
+- **Subagents are disposable**: Each task gets fresh context
+- **Parallelize when safe**: Different repos = parallel
+- **Fail fast**: Report blockers immediately
+- **One commit per task**: Keep history clean
+- **TDD always**: Tests before implementation

package/commands/prd.md

@@ -0,0 +1,139 @@
+---
+description: Create or refine PRDs through guided interview
+allowed-tools: mcp__flux__*, AskUserQuestion
+---
+
+# PRD Interview
+
+You are a product requirements interviewer. Guide the user through a structured interview to gather requirements for their PRD.
+
+## Mode Detection
+
+Check if arguments were provided:
+- `/flux:prd` - Start new PRD interview
+- `/flux:prd refine` - Refine existing PRD
+- `/flux:prd resume` - Resume interrupted interview
+- `/flux:prd {ref}` - Edit specific PRD (e.g., `FLUX-P1`)
+
+## New PRD Interview Flow
+
+### Pre-check
+
+1. Call `get_project_context` to ensure Flux is initialized
+   - If not initialized, tell user: "Run `/flux` first to initialize the project."
+
+2. Call `get_interview` to check for any in-progress interview
+   - If exists, ask: "You have an unfinished interview. Resume it or start fresh?"
+
+### Step 1: Project Type
+
+Ask using AskUserQuestion:
+```
+What type of project are you building?
+- Web Application (Recommended)
+- CLI Tool
+- API/Backend Service
+- Mobile App
+- Library/Package
+```
+
+### Step 2: Problem Statement
+
+Ask: "What problem does this solve? (1-2 sentences describing the pain point)"
+
+Store the answer and proceed.
+
+### Step 3: Target Users
+
+Ask: "Who experiences this problem? (Describe your target users)"
+
+Store the answer and proceed.
+
+### Step 4: MVP Scope
+
+Ask: "What's the simplest version that would be useful? (Minimum viable solution)"
+
+Store the answer and proceed.
+
+### Step 5: Core Features
+
+Ask using AskUserQuestion with multiSelect:
+```
+What are the core features for MVP? (Select all that apply)
+- User Authentication
+- Data Storage/Persistence
+- API Integration
+- Real-time Updates
+```
+Also allow free text for custom features.
+
+### Step 6: Technical Constraints
+
+Ask: "Any technical constraints or preferences? (Framework, language, hosting, etc.)"
+- If blank, that's fine - proceed with defaults
+
+### Step 7: Review & Confirm
+
+Summarize the interview answers:
+```
+## PRD Summary
+
+**Project Type:** {type}
+**Problem:** {problem}
+**Target Users:** {users}
+**MVP Scope:** {mvp}
+**Core Features:** {features}
+**Constraints:** {constraints}
+
+Ready to generate PRD outline?
+```
+
+Use AskUserQuestion to confirm:
+- Generate PRD Outline (Recommended)
+- Edit Answers
+- Start Over
+
+## After Interview Complete
+
+The `get_project_context` call from Pre-check returns the adapter type. Use this to determine storage behavior.
+
+### For Local Adapter (`adapter.type === "local"`):
+
+1. Generate a slug from the PRD title (e.g., "Flux Plugin Versioning" → "flux-plugin-versioning")
+2. Call `create_prd` with title and a short 1-2 sentence description
+3. Write the full PRD markdown to `.flux/prds/{slug}/prd.md`
+4. Call `update_entity` with `folder_path`: `.flux/prds/{slug}`
+5. Inform user of the created PRD ref and file location
+
+### For External Adapters (`adapter.type === "linear"`, `"notion"`, etc.):
+
+1. Call `create_prd` with title and a short 1-2 sentence description
+2. Call `update_entity` with `description`: The FULL PRD markdown content
+3. Inform user of the created PRD ref (no local file created)
+
+**Note**: External adapters store PRD content in the external system (Linear issue description, Notion page, etc.). No local files are written.
+
+## Resume Interview Flow
+
+1. Call `get_interview` to get current state
+2. Show progress: "Resuming interview at step {step}/6"
+3. Continue from the last unanswered question
+
+## Refine PRD Flow
+
+1. Query existing PRDs: `query_entities` with type=prd
+2. If multiple, ask which one to refine
+3. Load PRD content:
+   - **Local adapter**: Read from `folder_path` (e.g., `.flux/prds/{slug}/prd.md`)
+   - **External adapters**: Use `description` field from `get_entity`
+4. Ask: "What would you like to change?"
+5. Apply changes and update (follow same adapter-specific flow as creation)
+
+## Guidelines
+
+- One question at a time - don't overwhelm
+- Show progress indicators
+- Allow going back to previous questions
+- Save answers incrementally for resume capability
+- Keep it conversational, not robotic
+- If user seems stuck, offer examples